@Override public boolean equals(Object otherObject) { return (otherObject instanceof IQ) && projectionAtom.equals(((IQ) otherObject).getProjectionAtom()) && tree.isEquivalentTo(((IQ) otherObject).getTree()); }
/** * TODO: why a fix point? */ @Override public IQ optimize(IQ query) { TreeTransformer treeTransformer = new TreeTransformer(query.getVariableGenerator()); IQ prev; do { prev = query; query = iqFactory.createIQ( query.getProjectionAtom(), query.getTree().acceptTransformer(treeTransformer) ); } while (!prev.equals(query)); return query; } }
@Override public IQ optimize(IQ query) { IQ bindingLiftedQuery = query.liftBinding(); return liftUnionsInTree(bindingLiftedQuery); }
private IQ completeSameAsDefinition(IQ originalDefinition, RDFAtomPredicate rdfAtomPredicate) { ImmutableList<Variable> originalProjectedVariables = originalDefinition.getProjectionAtom().getArguments(); VariableGenerator originalVariableGenerator = originalDefinition.getVariableGenerator(); queryRenamer.transform(originalDefinition).getTree()); .liftBinding();
public ImmutableSet<Variable> getKnownVariables() { return definition.getTree().getKnownVariables(); }
private IQ canonizeWithJoin(IQ assertion, IntensionalQueryMerger intensionalQueryMerger, Position pos) { Optional<Variable> replacedVar = getReplacedVar(assertion, pos); if (replacedVar.isPresent()) { Variable newVariable = createFreshVariable(assertion, intensionalQueryMerger, replacedVar.get()); IntensionalDataNode idn = getIDN(replacedVar.get(), newVariable); RDFAtomPredicate pred = getRDFAtomPredicate(assertion.getProjectionAtom()); DistinctVariableOnlyDataAtom projAtom = atomFactory.getDistinctVariableOnlyDataAtom( pred, replaceProjVars( pred, assertion.getProjectionAtom().getArguments(), pos, newVariable)); IQ intensionalCanonizedQuery = iqFactory.createIQ( projAtom, getIntensionalCanonizedTree(assertion, projAtom, idn)); IQ canonizedQuery = intensionalQueryMerger.optimize(intensionalCanonizedQuery) .liftBinding(); return canonizedQuery.getTree().isDeclaredAsEmpty() // No matching canonical IRI template ? assertion : canonizedQuery; } return assertion; }
private static ImmutableSet<Constant> extractIRITemplates(IQ definition) { return Optional.of(definition.getProjectionAtom().getPredicate()) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> extractIRITemplates((RDFAtomPredicate) p, definition)) .orElseGet(ImmutableSet::of); }
private Optional<NaryIQTree> findFirstSplittableUnion(IQ query) { Queue<IQTree> nodesToVisit = new LinkedList<>(); nodesToVisit.add(query.getTree()); while(!nodesToVisit.isEmpty()) { IQTree childTree = nodesToVisit.poll(); if (childTree.getRootNode() instanceof UnionNode) { return Optional.of((NaryIQTree) childTree); } else { nodesToVisit.addAll(extractChildrenToVisit(childTree)); } } return Optional.empty(); }
private Optional<Variable> getReplacedVar(IQ assertion, Position pos) { switch (pos) { case SUBJECT: return Optional.of(getVarFromRDFAtom(assertion.getProjectionAtom(), pos)); case OBJECT: return MappingTools.extractRDFPredicate(assertion).isClass() ? Optional.empty() : Optional.of(getVarFromRDFAtom(assertion.getProjectionAtom(), pos)); default: throw new UnexpectedPositionException(pos); } }
@Override public IQ optimize(IQ query) { IQTree newTree = optimize(query.getTree()); return iqFactory.createIQ(query.getProjectionAtom(), newTree); }
@Override public Stream<IQ> splitUnion(IQ query) { DistinctVariableOnlyDataAtom projectionAtom = query.getProjectionAtom(); VariableGenerator variableGenerator = query.getVariableGenerator(); IQTree tree = query.getTree(); return findFirstSplittableUnion(query) .map(unionTree -> unionTree.getChildren().stream() .map(c -> tree.replaceSubTree(unionTree, c)) .map(t -> t.liftBinding(variableGenerator)) .map(t -> iqFactory.createIQ(projectionAtom, t)) .map(IQ::liftBinding)) .orElseGet(() -> Stream.of(query)); }
/** * Assumes that ORDER BY is ABOVE the first construction node */ private IQTree getFirstNonQueryModifierTree(IQ query) { // Non-final IQTree iqTree = query.getTree(); while (iqTree.getRootNode() instanceof QueryModifierNode) { iqTree = ((UnaryIQTree) iqTree).getChild(); } return iqTree; }
private ImmutableTable<RDFAtomPredicate, IRI, IQ> extractTable( ImmutableMap<IQ, MappingTools.RDFPredicateInfo> iqClassificationMap, boolean isClass) { return iqClassificationMap.entrySet().stream() .filter(e -> e.getValue().isClass() == isClass) .map(e -> Tables.immutableCell( (RDFAtomPredicate) e.getKey().getProjectionAtom().getPredicate(), e.getValue().getIri(), e.getKey())) .collect(ImmutableCollectors.toTable()); }
private IQ convertDatalogRule(CQIE datalogRule, ImmutableSet<Predicate> extensionalPredicates) { IQ directlyConvertedIQ = datalogRule2QueryConverter.convertDatalogRule( datalogRule, extensionalPredicates, Optional.empty(), iqFactory); return noNullValueEnforcer.transform(directlyConvertedIQ) .liftBinding(); }
@Override public IQ rewrite(IQ query) throws EmptyQueryException { return iqFactory.createIQ(query.getProjectionAtom(), query.getTree().acceptTransformer(new BasicGraphPatternTransformer(iqFactory) { @Override protected ImmutableList<IntensionalDataNode> transformBGP(ImmutableList<IntensionalDataNode> triplePatterns) { // optimise with Sigma ABox dependencies ArrayList<IntensionalDataNode> list = new ArrayList<>(triplePatterns); // this loop has to remain sequential (no streams) for (int i = 0; i < list.size(); i++) { ImmutableSet<DataAtom> derived = inclusionDependencyTools.chaseAtom(list.get(i).getProjectionAtom(), sigma); if (!derived.isEmpty()) { for (int j = 0; j < list.size(); j++) if (i != j && derived.contains(list.get(j).getProjectionAtom())) { list.remove(j); j--; } } } return ImmutableList.copyOf(list); } })); } }
/** * */ private IQ liftUnionsInTree(IQ query) { VariableGenerator variableGenerator = query.getVariableGenerator(); // Non-final IQTree previousTree; IQTree newTree = query.getTree(); int i=0; do { previousTree = newTree; newTree = liftTree(previousTree, variableGenerator) .liftBinding(variableGenerator); } while (!newTree.equals(previousTree) && (++i < ITERATION_BOUND)); if (i >= ITERATION_BOUND) throw new MinorOntopInternalBugException(getClass().getName() + " did not converge after " + ITERATION_BOUND + " iterations"); return newTree.equals(query.getTree()) ? query : iqFactory.createIQ(query.getProjectionAtom(), newTree); }
IQTree tree = query.getTree(); QueryNode rootNode = tree.getRootNode(); if (rootNode instanceof QueryModifierNode) {
/** * Hacked logic: because of ORDER conditions that are expected to use signature variables, * this method DOES NOT look for conflicts between signature variables and variables only appearing in the sub-tree. * * See the history for a better logic breaking this ugly hack. * * TODO: after getting rid of Datalog for encoding SPARQL queries, could try to clean it */ private IQ enforceSignature(IQ iq, ImmutableList<Variable> signature) { ImmutableList<Variable> projectedVariables = iq.getProjectionAtom().getArguments(); if (projectedVariables.equals(signature)) return iq; if (projectedVariables.size() != signature.size()) throw new IllegalArgumentException("The arity of the signature does not match the iq"); InjectiveVar2VarSubstitution renamingSubstitution = substitutionFactory.getInjectiveVar2VarSubstitution( IntStream.range(0, projectedVariables.size()) .boxed() .map(i -> Maps.immutableEntry(projectedVariables.get(i), signature.get(i))) .filter(e -> !e.getKey().equals(e.getValue())) .collect(ImmutableCollectors.toMap())); return queryTransformerFactory.createRenamer(renamingSubstitution) .transform(iq); }
private IntermediateQuery liftBinding(IntermediateQuery query) throws EmptyQueryException { IQ iq = iqConverter.convert(query); return iqConverter.convert(iq.liftBinding(), query.getDBMetadata(), query.getExecutorRegistry()); } }
private ImmutableList<IQ> normalizeIQ(IQ query) { IQTree tree = query.getTree(); while(tree.getRootNode() instanceof QueryModifierNode){ tree = ((UnaryIQTree)tree).getChild(); } return splitRootUnion(tree) .map(t -> enforceRootCn(t, query.getProjectionAtom().getVariables())) .map(t -> iqFactory.createIQ(query.getProjectionAtom(), t)) .collect(ImmutableCollectors.toList()); }