ReasonerQueryImpl (grakn-graql 1.4.2 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
`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()`
`ConceptMap`	`getRoleSubstitution()`
`ConceptMap`	`getSubstitution()` Does id predicates -> answer conversion
`Set<Var>`	`getVarNames()`
`com.google.common.collect.ImmutableMap<Var,Type>`	`getVarTypeMap()`
`com.google.common.collect.ImmutableMap<Var,Type>`	`getVarTypeMap(boolean inferTypes)`
`com.google.common.collect.ImmutableMap<Var,Type>`	`getVarTypeMap(ConceptMap 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`	`isAtomic()`
`boolean`	`isBoundlesslyDisconnected()`
`boolean`	`isEquivalent(ReasonerQueryImpl q)`
`boolean`	`isRuleResolvable()`
`boolean`	`isTypeRoleCompatible(Var typedVar, Type parentType)`
`ReasonerQueryImpl`	`positive()`
`Iterator<ResolutionState>`	`queryStateIterator(QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache)`
`boolean`	`requiresDecomposition()`
`boolean`	`requiresReiteration()` reiteration might be required if rule graph contains loops with negative flux or there exists a rule which head satisfies body
`boolean`	`requiresSchema()`
`java.util.stream.Stream<ConceptMap>`	`resolve()`
`ReasonerQueryImpl`	`rewrite()`
`java.util.stream.Stream<Atom>`	`selectAtoms()`
`ResolutionState`	`subGoal(ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache)`
`java.util.stream.Stream<ResolutionState>`	`subGoals(ConceptMap sub, Unifier u, QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<ReasonerAtomicQuery> cache)`
`String`	`toString()`
`ReasonerQueryImpl`	`transformIds(Map<Var,ConceptId> transform)`
`EmbeddedGraknTx<?>`	`tx()`
`Set<String>`	`validateOntologically()`
`ReasonerQueryImpl`	`withSubstitution(ConceptMap 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(ConceptMap 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 EmbeddedGraknTx<?> tx()
```
    Specified by:
    
    tx in interface ReasonerQuery
  - checkValid
```
public void checkValid()
```
    Specified by:
    
    checkValid 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
  - isBoundlesslyDisconnected
```
public boolean isBoundlesslyDisconnected()
```
    Returns:
    
    true if this query contains disconnected atoms that are unbounded
  - requiresSchema
```
public boolean requiresSchema()
```
    Returns:
    
    true if the query requires direct schema lookups
  - isAtomic
```
public boolean isAtomic()
```
    Returns:
    
    true if this query is atomic
  - 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)
```
    Specified by:
    
    getMultiUnifier in interface ReasonerQuery
  - getMultiUnifier
```
public MultiUnifier getMultiUnifier(ReasonerQuery parent,
                                    UnifierComparison unifierType)
```
    Specified by:
    
    getMultiUnifier in interface ReasonerQuery
  - 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(boolean inferTypes)
```
    Specified by:
    
    getVarTypeMap in interface ReasonerQuery
  - getVarTypeMap
```
public com.google.common.collect.ImmutableMap<Var,Type> getVarTypeMap(ConceptMap 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 java.util.stream.Stream<Atom> selectAtoms()
```
    Returns:
    
    selected atoms
  - getSubstitution
```
public ConceptMap getSubstitution()
```
    Does id predicates -> answer conversion
    
    Specified by:
    
    getSubstitution in interface ReasonerQuery
    
    Returns:
    
    substitution obtained from all id predicates (including internal) in the query
  - getRoleSubstitution
```
public ConceptMap getRoleSubstitution()
```
  - requiresDecomposition
```
public boolean requiresDecomposition()
```
    Returns:
    
    true if this query requires atom decomposition
  - rewrite
```
public ReasonerQueryImpl rewrite()
```
    Returns:
    
    rewritten (decomposed) version of the query
  - resolve
```
public java.util.stream.Stream<ConceptMap> resolve()
```
    Specified by:
    
    resolve in interface ReasonerQuery
  - subGoal
```
public ResolutionState subGoal(ConceptMap sub,
                               Unifier u,
                               QueryStateBase parent,
                               Set<ReasonerAtomicQuery> subGoals,
                               SimpleQueryCache<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(ConceptMap sub,
                                                         Unifier u,
                                                         QueryStateBase parent,
                                                         Set<ReasonerAtomicQuery> subGoals,
                                                         SimpleQueryCache<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 Iterator<ResolutionState> queryStateIterator(QueryStateBase parent,
                                                    Set<ReasonerAtomicQuery> subGoals,
                                                    SimpleQueryCache<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

Class ReasonerQueryImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

conjunction

withSubstitution

inferTypes

positive

transformIds

toString

copy

equals

hashCode

isEquivalent

tx

checkValid

getPattern

validateOntologically

isRuleResolvable

isBoundlesslyDisconnected

requiresSchema

isAtomic

isTypeRoleCompatible

getAtoms

getAtoms

getVarNames

getMultiUnifier

getMultiUnifier

getQuery

getVarTypeMap

getVarTypeMap

getVarTypeMap

idTransform

selectAtoms

getSubstitution

getRoleSubstitution

requiresDecomposition

rewrite

resolve

subGoal

subGoals

queryStateIterator

requiresReiteration