public ImmutableSet<Variable> getKnownVariables() { return definition.getTree().getKnownVariables(); }
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(); }
@Override public boolean equals(Object otherObject) { return (otherObject instanceof IQ) && projectionAtom.equals(((IQ) otherObject).getProjectionAtom()) && tree.isEquivalentTo(((IQ) otherObject).getTree()); }
/** * 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; }
@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)); }
private static PredicateClassification classify(ImmutableSet<Constant> sameAsIriTemplates, IQ definition, RDFAtomPredicate rdfAtomPredicate, boolean isClass) { ImmutableList<Variable> variables = definition.getProjectionAtom().getArguments(); /* * Current limitation: is the object is concerned about SameAs rewriting, the subject is supposed also * concerned. * TODO: enrich the classification */ if (!isClass && extractIRITemplates(rdfAtomPredicate.getObject(variables), definition.getTree()) .anyMatch(sameAsIriTemplates::contains)) { return PredicateClassification.AT_LEAST_OBJECT; } return extractIRITemplates(rdfAtomPredicate.getSubject(variables), definition.getTree()) .filter(sameAsIriTemplates::contains) .findAny() .map(t -> PredicateClassification.SUBJECT_ONLY) .orElse(PredicateClassification.NONE); }
@Override public IQ optimize(IQ query) { IQTree newTree = optimize(query.getTree()); return iqFactory.createIQ(query.getProjectionAtom(), newTree); }
private static ImmutableSet<Constant> extractIRITemplates(RDFAtomPredicate predicate, IQ definition) { ImmutableList<Variable> projectedVariables = definition.getProjectionAtom().getArguments(); return Stream.of(predicate.getSubject(projectedVariables), predicate.getObject(projectedVariables)) .flatMap(v -> extractIRITemplates(v, definition.getTree())) .collect(ImmutableCollectors.toSet()); }
private IQTree getIntensionalCanonizedTree(IQ assertion, DistinctVariableOnlyDataAtom projAtom, IntensionalDataNode intensionalDataNode) { return iqFactory.createUnaryIQTree( iqFactory.createConstructionNode(projAtom.getVariables()), iqFactory.createNaryIQTree( iqFactory.createInnerJoinNode(), ImmutableList.of( assertion.getTree(), intensionalDataNode ))); }
private Variable createFreshVariable(IQ assertion, IntensionalQueryMerger intensionalQueryMerger, Variable formerVariable) { VariableGenerator variableGenerator = coreUtilsFactory.createVariableGenerator( Sets.union( assertion.getTree().getKnownVariables(), intensionalQueryMerger.getKnownVariables()).immutableCopy()); return variableGenerator.generateNewVariableFromVar(formerVariable); }
private IQ appendSuffixToVariableNames(IQ query, int suffix) { Map<Variable, Variable> substitutionMap = query.getTree().getKnownVariables().stream() .collect(Collectors.toMap( v -> v, v -> termFactory.getVariable(v.getName()+"m"+suffix))); QueryRenamer queryRenamer = transformerFactory.createRenamer(substitutionFactory.getInjectiveVar2VarSubstitution(substitutionMap)); return queryRenamer.transform(query); } }
@Override public IQ transform(IQ originalQuery) { IQTree tree = originalQuery.getTree(); ImmutableSet<ImmutableSet<Variable>> nullableGroups = tree.getVariableNullability().getNullableGroups(); return nullableGroups.isEmpty() ? originalQuery : insertFilter(originalQuery, nullableGroups); }
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()); }
@Override public IntermediateQuery convert(IQ query, DBMetadata dbMetadata, ExecutorRegistry executorRegistry) throws EmptyQueryException { if (query.getTree().isDeclaredAsEmpty()) throw new EmptyQueryException(); IntermediateQueryBuilder queryBuilder = iqFactory.createIQBuilder(dbMetadata, executorRegistry); IQTree topTree = query.getTree(); QueryNode rootNode = topTree.getRootNode(); queryBuilder.init(query.getProjectionAtom(), rootNode); insertChildren(rootNode, topTree.getChildren(), queryBuilder); return queryBuilder.build(); }
/** * 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; } }
public static RDFPredicateInfo extractRDFPredicate(IQ mappingAssertion) { DistinctVariableOnlyDataAtom projectionAtom = mappingAssertion.getProjectionAtom(); RDFAtomPredicate rdfAtomPredicate = Optional.of(projectionAtom.getPredicate()) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .orElseThrow(() -> new MappingPredicateIRIExtractionException("The following mapping assertion " + "is not having a RDFAtomPredicate: " + mappingAssertion)); ImmutableSet<ImmutableList<? extends ImmutableTerm>> possibleSubstitutedArguments = mappingAssertion.getTree().getPossibleVariableDefinitions().stream() .map(s -> s.apply(projectionAtom.getArguments())) .collect(ImmutableCollectors.toSet()); IRI propertyIRI = extractIRI(possibleSubstitutedArguments, rdfAtomPredicate::getPropertyIRI); return propertyIRI.equals(RDF.TYPE) ? new RDFPredicateInfo(true, extractIRI(possibleSubstitutedArguments, rdfAtomPredicate::getClassIRI)) : new RDFPredicateInfo(false, propertyIRI); }
private static void checkNullableVariables(IQ query) throws NullableVariableInMappingException { VariableNullability variableNullability = query.getTree().getVariableNullability(); if (!variableNullability.getNullableGroups().isEmpty()) throw new NullableVariableInMappingException(query, variableNullability.getNullableGroups()); }
private static void checkNullableVariables(IQ query) throws NullableVariableInMappingException { VariableNullability variableNullability = query.getTree().getVariableNullability(); if (!variableNullability.getNullableGroups().isEmpty()) throw new NullableVariableInMappingException(query, variableNullability.getNullableGroups()); }
private IQ insertFilter(IQ originalQuery, ImmutableSet<ImmutableSet<Variable>> nullableVariables) { FilterNode filterNode = iQFactory.createFilterNode(computeFilterExpression(nullableVariables)); UnaryIQTree newTree = iQFactory.createUnaryIQTree(filterNode, originalQuery.getTree()); // TODO: normalize it return iQFactory.createIQ(originalQuery.getProjectionAtom(), newTree); } }
@Override public IQ transform(IQ originalQuery) { QueryNodeRenamer nodeTransformer = new QueryNodeRenamer(iqFactory, renamingSubstitution, atomFactory); HomogeneousIQTreeVisitingTransformer iqTransformer = new HomogeneousIQTreeVisitingTransformer(nodeTransformer, iqFactory); IQTree newIQTree = originalQuery.getTree().acceptTransformer(iqTransformer); DistinctVariableOnlyDataAtom newProjectionAtom = transformProjectionAtom(originalQuery.getProjectionAtom()); return iqFactory.createIQ(newProjectionAtom, newIQTree); } }