ReasonerQueryImpl (Grakn 0.11.0 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

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addAtom(Atomic atom)`
`void`	`addAtomConstraints(Set<? extends Atomic> cstrs)` adds a set of constraints (types, predicates) to the atom set
`boolean`	`containsEquivalentAtom(Atomic atom)`
`boolean`	`equals(Object obj)`
`Set<Atomic>`	`getAtoms()`
`Set<Atomic>`	`getEquivalentAtoms(Atomic atom)`
`Set<NotEquals>`	`getFilters()`
`IdPredicate`	`getIdPredicate(VarName var)`
`Set<IdPredicate>`	`getIdPredicates()`
`MatchQuery`	`getMatchQuery()`
`Conjunction<PatternAdmin>`	`getPattern()`
`Set<TypeAtom>`	`getTypeConstraints()`
`Map<VarName,VarName>`	`getUnifiers(ReasonerQuery parent)`
`Set<ValuePredicate>`	`getValuePredicates()`
`Set<VarName>`	`getVarNames()`
`Map<VarName,Type>`	`getVarTypeMap()`
`GraknGraph`	`graph()`
`int`	`hashCode()`
`boolean`	`isEquivalent(ReasonerQueryImpl q)`
`boolean`	`isRuleResolvable()`
`boolean`	`removeAtom(Atomic atom)`
`java.util.stream.Stream<Map<VarName,Concept>>`	`resolve(boolean materialise)` resolves the query
`Set<Atom>`	`selectAtoms()` atom selection function
`String`	`toString()`
`void`	`unify(Map<VarName,VarName> unifiers)` 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
  - 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
  - getEquivalentAtoms
```
public Set<Atomic> getEquivalentAtoms(Atomic atom)
```
  - getUnifiers
```
public Map<VarName,VarName> getUnifiers(ReasonerQuery parent)
```
    Specified by:
    
    getUnifiers 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(Map<VarName,VarName> unifiers)
```
    change each variable occurrence according to provided mappings (apply unifiers {[from, to]_i})
    
    Specified by:
    
    unify in interface ReasonerQuery
    
    Parameters:
    
    unifiers - contain unifiers (variable mappings) to be applied
  - getMatchQuery
```
public MatchQuery getMatchQuery()
```
    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
  - addAtom
```
public boolean addAtom(Atomic atom)
```
    Parameters:
    
    atom - to be added
    
    Returns:
    
    true if the atom set did not already contain the specified atom
  - removeAtom
```
public boolean removeAtom(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
  - 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<Map<VarName,Concept>> resolve(boolean materialise)
```
    resolves the query
    
    Specified by:
    
    resolve in interface ReasonerQuery
    
    Parameters:
    
    materialise - materialisation flag
    
    Returns:
    
    stream of answers

Class ReasonerQueryImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ReasonerQueryImpl

ReasonerQueryImpl

ReasonerQueryImpl

Method Detail

equals

hashCode

toString

graph

getPattern

isRuleResolvable

getAtoms

getIdPredicates

getValuePredicates

getTypeConstraints

getFilters

getVarNames

containsEquivalentAtom

getEquivalentAtoms

getUnifiers

unify

unify

getMatchQuery

getVarTypeMap

getIdPredicate

addAtom

removeAtom

addAtomConstraints

selectAtoms

isEquivalent

resolve