private Optional<IQ> getStarDefinition(RDFAtomPredicate predicate) { return queryMerger.mergeDefinitions(mapping.getQueries(predicate)); }
/** * TODO: explain */ protected DefaultQueryTreeComponent(QueryTree tree) { this(tree, new VariableGenerator( VariableCollector.collectVariables( tree.getNodesInTopDownOrder()))); }
VariableOccurrenceAnalyzer analyzer = new NaiveVariableOccurrenceAnalyzerImpl(); .allMatch(v -> ! analyzer.isVariableUsedSomewhereElse(query, targetDataNode, v));
@Override public <R extends ProposalResults, P extends QueryOptimizationProposal<R>> R applyProposal(P proposal, boolean disableValidationTests) throws InvalidQueryOptimizationProposalException, EmptyQueryException { if ((!disableValidationTests) && settings.isTestModeEnabled()) { validate(); } ProposalExecutor<P, R> executor = executorRegistry.getExecutor(proposal); /** * Has a SIDE-EFFECT on the tree component. */ R results = executor.apply(proposal, this, treeComponent); if ((!disableValidationTests) && settings.isTestModeEnabled()) { validate(); } return results; }
private Stream<CQIE> convertMappingQuery(IntermediateQuery mappingQuery) { ImmutableSet<CQIE> rules = unionSplitter.splitUnion(mappingQuery) .flatMap(q -> iq2DatalogTranslator.translate(q).getRules().stream()) .collect(ImmutableCollectors.toSet()); //CQIEs are mutable rules.forEach(DatalogNormalizer::unfoldJoinTrees); return rules.stream(); } }
@Override public NodeCentricOptimizationResults<N> apply(SubstitutionPropagationProposal<N> proposal, IntermediateQuery query, QueryTreeComponent treeComponent) throws InvalidQueryOptimizationProposalException { N focusNode = proposal.getFocusNode(); IQTree propagatedSubTree = propagate(iqConverter.convertTree(query, focusNode), proposal.getSubstitution()); treeComponent.replaceSubTreeByIQ(focusNode, propagatedSubTree); return new NodeCentricOptimizationResultsImpl<>(query, Optional.of(propagatedSubTree.getRootNode())); }
/** * Due to a Java compiler bug (hiding .orElseThrow() in a sub-method does the trick) */ private IQ mergeDefinitions(Collection<IQ> queries) { return queryMerger.mergeDefinitions(queries) .orElseThrow(() -> new MappingMergingException("The query should be present")); } }
VariableOccurrenceAnalyzer analyzer = new NaiveVariableOccurrenceAnalyzerImpl(); .noneMatch(v -> analyzer.isVariableUsedSomewhereElse(query, targetDataNode, v));
/** * TODO: explain */ protected DefaultQueryTreeComponent(QueryTree tree, CoreUtilsFactory coreUtilsFactory) { this(tree, coreUtilsFactory.createVariableGenerator( VariableCollector.collectVariables( tree.getNodesInTopDownOrder()))); }
@Override public <R extends ProposalResults, P extends QueryOptimizationProposal<R>> R applyProposal(P proposal, boolean disableValidationTests) throws InvalidQueryOptimizationProposalException, EmptyQueryException { if ((!disableValidationTests) && settings.isTestModeEnabled()) { validate(); } ProposalExecutor<P, R> executor = executorRegistry.getExecutor(proposal); /** * Has a SIDE-EFFECT on the tree component. */ R results = executor.apply(proposal, this, treeComponent); if ((!disableValidationTests) && settings.isTestModeEnabled()) { validate(); } return results; }
/** * Due to a Java compiler bug (hiding .orElseThrow() in a sub-method does the trick) */ private IntermediateQuery mergeDefinitions(Collection<IntermediateQuery> queries) { return queryMerger.mergeDefinitions(queries) .map(mappingIQNormalizer::normalize) .orElseThrow(() -> new MappingMergingException("The query should be present")); }
private IQ normalizeIQ(IntermediateQuery intermediateQuery) { // Trick for pushing down expressions under unions: // - there the context may be concrete enough for evaluating certain expressions // - useful for dealing with SPARQL EBVs for instance IntermediateQuery pushedDownQuery = pushDownExpressionOptimizer.optimize(intermediateQuery); log.debug("New query after pushing down the boolean expressions (temporary): \n" + pushedDownQuery); IQ flattenIQ = unionFlattener.optimize(iqConverter.convert(pushedDownQuery)); log.debug("New query after flattening the union: \n" + flattenIQ); IQTree treeAfterPullOut = optimizerFactory.createEETransformer(flattenIQ.getVariableGenerator()).transform(flattenIQ.getTree()); log.debug("Query tree after pulling out equalities: \n" + treeAfterPullOut); // Pulling up is needed when filtering conditions appear above a data atom on the left // (causes problems to the IQ2DatalogConverter) try { IntermediateQuery queryAfterPullUp = pullUpExpressionOptimizer.optimize(iqConverter.convert( iqFactory.createIQ(flattenIQ.getProjectionAtom(), treeAfterPullOut), intermediateQuery.getDBMetadata(), intermediateQuery.getExecutorRegistry())); log.debug("New query after pulling up the boolean expressions: \n" + queryAfterPullUp); return iqConverter.convert(queryAfterPullUp); } catch (EmptyQueryException e) { // Not expected throw new MinorOntopInternalBugException(e.getMessage()); } }
private IQ mergeDefinitions(Collection<IQ> assertions) { return queryMerger.mergeDefinitions(assertions) .orElseThrow(() -> new MinorOntopInternalBugException("Could not merge assertions: " + assertions)); }
@Override public Optional<IQ> convertDatalogDefinitions(Collection<CQIE> atomDefinitions, Collection<Predicate> tablePredicates, Optional<ImmutableQueryModifiers> optionalModifiers) throws InvalidDatalogProgramException { switch(atomDefinitions.size()) { case 0: return Optional.empty(); case 1: CQIE definition = atomDefinitions.iterator().next(); return Optional.of(datalogRuleConverter.convertDatalogRule(definition, tablePredicates, optionalModifiers, iqFactory)); default: List<IQ> convertedDefinitions = new ArrayList<>(); for (CQIE datalogAtomDefinition : atomDefinitions) { convertedDefinitions.add( datalogRuleConverter.convertDatalogRule(datalogAtomDefinition, tablePredicates, Optional.empty(), iqFactory)); } return optionalModifiers.isPresent() ? queryMerger.mergeDefinitions(convertedDefinitions, optionalModifiers.get()) : queryMerger.mergeDefinitions(convertedDefinitions); } }
private Optional<IQ> getStarClassDefinition(RDFAtomPredicate predicate) { return queryMerger.mergeDefinitions(mapping.getRDFClasses(predicate).stream() .flatMap(i -> mapping.getRDFClassDefinition(predicate, i) .map(Stream::of) .orElseGet(Stream::empty)) .collect(ImmutableCollectors.toList())); }
? queryMerger.mergeDefinitions(convertedDefinitions, optionalModifiers.get()) : queryMerger.mergeDefinitions(convertedDefinitions);
private Optional<IQ> extractCanIRIDefinition(MappingWithProvenance mapping) { return queryMerger.mergeDefinitions( mapping.getProvenanceMap().keySet().stream() .filter(q -> (MappingTools.extractRDFPredicate(q).getIri().equals(Ontop.CANONICAL_IRI))) .collect(ImmutableCollectors.toList())); }
queryRenamer.transform(originalDefinition).getTree()); return queryMerger.mergeDefinitions(ImmutableList.of(originalDefinition, inversedDefinition)) .get() .liftBinding();