private Stream<ConceptMap> runMatchInsert(Match match, Collection<VarPatternAdmin> varPatterns) { Set<Var> varsInMatch = match.admin().getSelectedNames(); Set<Var> varsInInsert = varPatterns.stream().map(VarPatternAdmin::var).collect(toImmutableSet()); Set<Var> projectedVars = Sets.intersection(varsInMatch, varsInInsert); Stream<ConceptMap> answers = match.get(projectedVars).stream(); return answers.map(answer -> QueryOperationExecutor.insertAll(varPatterns, tx, answer)).collect(toList()).stream(); }
/** * find specific answer to a query in the cache * @param query input query * @param ans sought specific answer to the query * @return found answer if any, otherwise empty answer */ public ConceptMap getAnswer(Q query, ConceptMap ans){ if(ans.isEmpty()) return ans; CacheEntry<Q, QueryAnswers> match = this.getEntry(query); if (match != null) { Q equivalentQuery = match.query(); MultiUnifier multiUnifier = equivalentQuery.getMultiUnifier(query); //NB: only used when checking for materialised answer duplicates ConceptMap answer = match.cachedElement().stream() .flatMap(a -> a.unify(multiUnifier)) .filter(a -> a.containsAll(ans)) .findFirst().orElse(null); if (answer != null) return answer; } //TODO should it create a cache entry? List<ConceptMap> answers = ReasonerQueries.create(query, ans).getQuery().execute(); return answers.isEmpty()? new ConceptMapImpl() : answers.iterator().next(); } }
/** * @param atom of interest * @return stream of rules applicable to this atom */ public Stream<InferenceRule> getApplicableRules(Atom atom){ return atom.getApplicableRules() .filter( r -> { if (fruitlessRules.contains(r.getRule())) return false; if (r.getBody().isRuleResolvable() || checkedRules.contains(r.getRule())) return true; boolean fruitless = !r.getBody().getQuery().stream().findFirst().isPresent(); if (fruitless) { fruitlessRules.add(r.getRule()); return false; } checkedRules.add(r.getRule()); return true; }); }
/** * @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 Iterator<ResolutionState> queryStateIterator(QueryStateBase parent, Set<ReasonerAtomicQuery> subGoals, SimpleQueryCache<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(); ResolutionQueryPlan queryPlan = new ResolutionQueryPlan(this); subGoalIterator = Iterators.singletonIterator(new CumulativeState(queryPlan.queries(), new ConceptMapImpl(), parent.getUnifier(), parent, subGoals, cache)); } return Iterators.concat(dbIterator, subGoalIterator); }
/** * Get the resource edge id if there is one. Return null if not. */ public static ConceptId getResourceEdgeId(GraknTx graph, ConceptId conceptId1, ConceptId conceptId2) { if (mayHaveResourceEdge(graph, conceptId1, conceptId2)) { Optional<Concept> firstConcept = graph.graql().match( var("x").id(conceptId1), var("y").id(conceptId2), var("z").rel(var("x")).rel(var("y"))) .get("z") .stream().map(answer -> answer.get("z")) .findFirst(); if (firstConcept.isPresent()) { return firstConcept.get().id(); } } return null; }
@Override public Pair<Stream<ConceptMap>, MultiUnifier> getAnswerStreamWithUnifier(Q query) { CacheEntry<Q, LazyAnswerIterator> match = this.getEntry(query); if (match != null) { Q equivalentQuery = match.query(); MultiUnifier multiUnifier = equivalentQuery.getMultiUnifier(query); Stream<ConceptMap> unified = match.cachedElement().stream().flatMap(a -> a.unify(multiUnifier)); return new Pair<>(unified, multiUnifier); } Stream<ConceptMap> answerStream = record( query, query.getQuery().stream().map(a -> a.explain(new LookupExplanation(query))) ); return new Pair<>(answerStream, new MultiUnifierImpl()); }
@Override public Pair<LazyAnswerIterator, MultiUnifier> getAnswersWithUnifier(Q query) { CacheEntry<Q, LazyAnswerIterator> match = this.getEntry(query); if (match != null) { Q equivalentQuery = match.query(); MultiUnifier multiUnifier = equivalentQuery.getMultiUnifier(query); LazyAnswerIterator unified = match.cachedElement().unify(multiUnifier); return new Pair<>(unified, multiUnifier); } Stream<ConceptMap> answerStream = record( query, query.getQuery().stream().map(a -> a.explain(new LookupExplanation(query))) ); return new Pair<>(new LazyAnswerIterator(answerStream), new MultiUnifierImpl()); }