ReasonerQueryImpl (grakn-graql 0.17.1 API)

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

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ReasonerQuery`	`copy()`
`boolean`	`equals(Object obj)`
`Set<Atomic>`	`getAtoms()`
`<T extends Atomic> java.util.stream.Stream<T>`	`getAtoms(Class<T> type)`
`IdPredicate`	`getIdPredicate(Var var)`
`MultiUnifier`	`getMultiUnifier(ReasonerQuery parent)`
`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()`
`ReasonerQueryImpl`	`inferTypes()`
`boolean`	`isEquivalent(ReasonerQueryImpl q)`
`boolean`	`isGround()`
`boolean`	`isRuleResolvable()`
`boolean`	`isTypeRoleCompatible(Var typedVar, Type parentType)`
`ReasonerQueryImpl`	`positive()`
`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
`QueryState`	`subGoal(Answer sub, Unifier u, QueryState parent, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache)`
`LinkedList<QueryState>`	`subGoals(Answer sub, Unifier u, QueryState parent, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache)`
`String`	`toString()`
`GraknTx`	`tx()`
`Set<String>`	`validateOntologically()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - inferTypes
```
public ReasonerQueryImpl inferTypes()
```
    Returns:
    
    corresponding reasoner query with inferred types
  - positive
```
public ReasonerQueryImpl positive()
```
    Returns:
    
    corresponding positive query (with neq predicates removed)
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - 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
  - 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
  - getPattern
```
public Conjunction<PatternAdmin> getPattern()
```
    Specified by:
    
    getPattern in interface ReasonerQuery
  - validateOntologically
```
public Set<String> validateOntologically()
```
    Specified by:
    
    validateOntologically in interface ReasonerQuery
  - 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
  - isTypeRoleCompatible
```
public boolean isTypeRoleCompatible(Var typedVar,
                                    Type parentType)
```
    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
    
    Returns:
    
    atom set defining this reasoner query
  - getAtoms
```
public <T extends Atomic> java.util.stream.Stream<T> getAtoms(Class<T> type)
```
    Specified by:
    
    getAtoms in interface ReasonerQuery
    
    Type Parameters:
    
    T - the type of Atomic to return
    
    Parameters:
    
    type - the class of Atomic to return
    
    Returns:
    
    stream of atoms of specified type defined in this query
  - getVarNames
```
public Set<Var> getVarNames()
```
    Specified by:
    
    getVarNames in interface ReasonerQuery
    
    Returns:
    
    set of variables appearing in this query
  - getMultiUnifier
```
public MultiUnifier getMultiUnifier(ReasonerQuery parent)
```
    Specified by:
    
    getMultiUnifier in interface ReasonerQuery
  - getQuery
```
public GetQuery getQuery()
```
    Specified by:
    
    getQuery in interface ReasonerQuery
    
    Returns:
    
    corresponding 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
  - getIdPredicate
```
@Nullable
public IdPredicate getIdPredicate(Var var)
```
    Parameters:
    
    var - variable name
    
    Returns:
    
    id predicate for the specified var name if any
  - selectAtoms
```
public Set<Atom> selectAtoms()
```
    atom selection function
    
    Returns:
    
    selected atoms
  - getSubstitution
```
public Answer getSubstitution()
```
    Returns:
    
    substitution obtained from all id predicates (including internal) in the query
  - getRoleSubstitution
```
public Answer getRoleSubstitution()
```
  - isGround
```
public boolean isGround()
```
    Returns:
    
    true if this query is a ground query
  - resolve
```
public java.util.stream.Stream<Answer> resolve(boolean materialise)
```
    Specified by:
    
    resolve in interface ReasonerQuery
  - subGoal
```
public QueryState subGoal(Answer sub,
                          Unifier u,
                          QueryState 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 LinkedList<QueryState> subGoals(Answer sub,
                                       Unifier u,
                                       QueryState 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
  - 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

Class ReasonerQueryImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

inferTypes

positive

toString

copy

equals

hashCode

isEquivalent

tx

getPattern

validateOntologically

isRuleResolvable

isTypeRoleCompatible

getAtoms

getAtoms

getVarNames

getMultiUnifier

getQuery

getVarTypeMap

getVarTypeMap

getIdPredicate

selectAtoms

getSubstitution

getRoleSubstitution

isGround

resolve

subGoal

subGoals

requiresReiteration