Examples with Pair ai.grakn.graql.internal.reasoner.utils.Pair used on opensource projects

Example 6 with Pair

use of ai.grakn.graql.internal.reasoner.utils.Pair in project grakn by graknlabs.

the class IsaAtomBase method getTypedPair.

Pair<VarPattern, IdPredicate> getTypedPair(SchemaConcept type) {
    ConceptId typeId = type.getId();
    Var typeVariable = getPredicateVariable().getValue().isEmpty() ? Graql.var().asUserDefined() : getPredicateVariable();
    IdPredicate newPredicate = IdPredicate.create(typeVariable.id(typeId).admin(), getParentQuery());
    return new Pair<>(getPattern(), newPredicate);
}

Example 7 with Pair

use of ai.grakn.graql.internal.reasoner.utils.Pair in project grakn by graknlabs.

the class ReasonerQueryImpl method queryStateIterator.

/**
 * @param parent parent state
 * @param subGoals set of visited sub goals
 * @param cache query cache
 * @return query state iterator (db iter + unifier + state iter) for this query
 */
public Pair<Iterator<ResolutionState>, MultiUnifier> queryStateIterator(QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, QueryCache<ReasonerAtomicQuery> cache) {
    Iterator<AnswerState> dbIterator;
    Iterator<QueryStateBase> subGoalIterator;
    if (!this.isRuleResolvable()) {
        dbIterator = this.getQuery().stream().map(ans -> ans.explain(new JoinExplanation(this, ans))).map(ans -> new AnswerState(ans, parent.getUnifier(), parent)).iterator();
        subGoalIterator = Collections.emptyIterator();
    } else {
        dbIterator = Collections.emptyIterator();
        LinkedList<ReasonerQueryImpl> subQueries = new ResolutionPlan(this).queryPlan();
        LOG.trace("CQ plan:\n" + subQueries.stream().map(sq -> sq.toString() + (sq.isRuleResolvable() ? "*" : "")).collect(Collectors.joining("\n")));
        subGoalIterator = Iterators.singletonIterator(new CumulativeState(subQueries, new QueryAnswer(), parent.getUnifier(), parent, subGoals, cache));
    }
    return new Pair<>(Iterators.concat(dbIterator, subGoalIterator), new MultiUnifierImpl());
}

Example 8 with Pair

use of ai.grakn.graql.internal.reasoner.utils.Pair in project grakn by graknlabs.

the class LazyQueryCache method getAnswerStreamWithUnifier.

@Override
public Pair<Stream<Answer>, MultiUnifier> getAnswerStreamWithUnifier(Q query) {
    CacheEntry<Q, LazyAnswerIterator> match = this.getEntry(query);
    if (match != null) {
        Q equivalentQuery = match.query();
        MultiUnifier multiUnifier = equivalentQuery.getMultiUnifier(query);
        Stream<Answer> unified = match.cachedElement().stream().flatMap(a -> a.unify(multiUnifier));
        return new Pair<>(unified, multiUnifier);
    }
    Stream<Answer> answerStream = record(query, query.getQuery().stream().map(a -> a.explain(new LookupExplanation(query))));
    return new Pair<>(answerStream, new MultiUnifierImpl());
}

Example 9 with Pair

use of ai.grakn.graql.internal.reasoner.utils.Pair in project grakn by graknlabs.

the class QueryAnswerStream method joinWithInverse.

/**
 * lazy stream join with fast lookup from inverse answer map
 * @param stream left stream operand
 * @param stream2 right stream operand
 * @param stream2InverseMap inverse map of right operand from cache
 * @param joinVars intersection on variables of two streams
 * @return joined stream
 */
static Stream<Answer> joinWithInverse(Stream<Answer> stream, Stream<Answer> stream2, Map<Pair<Var, Concept>, Set<Answer>> stream2InverseMap, ImmutableSet<Var> joinVars) {
    if (joinVars.isEmpty()) {
        LazyAnswerIterator l2 = new LazyAnswerIterator(stream2);
        return stream.flatMap(a1 -> l2.stream().map(a -> a.merge(a1)));
    }
    return stream.flatMap(a1 -> {
        Iterator<Var> vit = joinVars.iterator();
        Set<Answer> matchAnswers = findMatchingAnswers(a1, stream2InverseMap, vit.next());
        while (vit.hasNext()) {
            matchAnswers = Sets.intersection(matchAnswers, findMatchingAnswers(a1, stream2InverseMap, vit.next()));
        }
        return matchAnswers.stream().map(a -> a.merge(a1));
    });
}

Example 10 with Pair

use of ai.grakn.graql.internal.reasoner.utils.Pair in project grakn by graknlabs.

the class ReasonerAtomicQuery method answerStream.

/**
 * resolves the query by performing lookups and rule resolution and returns a stream of new answers
 * @param subGoals visited subGoals (recursive queries)
 * @param cache global query cache
 * @param dCache differential query cache
 * @return stream of differential answers
 */
Stream<Answer> answerStream(Set<ReasonerAtomicQuery> subGoals, Cache<ReasonerAtomicQuery, ?> cache, Cache<ReasonerAtomicQuery, ?> dCache, boolean differentialJoin) {
    boolean queryAdmissible = !subGoals.contains(this);
    LOG.trace("AQ: " + this);
    Stream<Answer> answerStream = cache.contains(this) ? Stream.empty() : dCache.record(this, cache.getAnswerStream(this));
    if (queryAdmissible) {
        Iterator<Pair<InferenceRule, Unifier>> ruleIterator = getRuleStream().iterator();
        while (ruleIterator.hasNext()) {
            Pair<InferenceRule, Unifier> ruleContext = ruleIterator.next();
            Unifier unifier = ruleContext.getValue();
            Unifier unifierInverse = unifier.inverse();
            Answer sub = this.getSubstitution().unify(unifierInverse);
            InferenceRule rule = ruleContext.getKey().propagateConstraints(getAtom(), unifierInverse).withSubstitution(sub);
            Stream<Answer> localStream = resolveViaRule(rule, unifier, subGoals, cache, dCache, differentialJoin);
            answerStream = Stream.concat(answerStream, localStream);
        }
    }
    return dCache.record(this, answerStream);
}