private IQTree createJoinSubtree(int childIndex, IQTree unionGrandChild, ImmutableList<IQTree> initialChildren) { return iqFactory.createNaryIQTree(this, IntStream.range(0, initialChildren.size()) .boxed() .map(i -> i == childIndex ? unionGrandChild : initialChildren.get(i)) .collect(ImmutableCollectors.toList())); }
private PartialExtraction(Stream<Map.Entry<Variable, ImmutableTerm>> mergedBindings, ImmutableSet<Variable> mergedVariables) { this.mergedBindings = mergedBindings.collect(ImmutableCollectors.toMap()); this.mergedVariables = mergedVariables; } // private PartialExtraction(Stream<Map.Entry<Variable, ImmutableTerm>> mergedBindings, ImmutableSet<Variable> mergedVariables) {
@Override public ImmutableSet<Variable> getVariables() { return arguments.stream() .flatMap(ImmutableTerm::getVariableStream) .collect(ImmutableCollectors.toSet()); }
private static ImmutableMap<CQIE, ImmutableList<Optional<TermType>>> extractTermTypeMap(Collection<CQIE> rules) throws IncompatibleTermException { return rules.stream() .collect(ImmutableCollectors.toMap( // Key mapper rule -> rule, // Value mapper rule -> rule.getHead().getTerms().stream() .map(TermTypeInferenceTools::inferType) .collect(ImmutableCollectors.toList()) )); }
private ImmutableMap<AtomPredicate, IntermediateQuery> mergeMappingMaps(ImmutableSet<Mapping> mappings) { ImmutableMap<AtomPredicate, Collection<IntermediateQuery>> atomPredicate2IQs = mappings.stream() .flatMap(m -> getMappingMap(m).entrySet().stream()) .collect(ImmutableCollectors.toMultimap()) .asMap(); return atomPredicate2IQs.entrySet().stream() .collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> mergeDefinitions(e.getValue()) )); }
private IQTree liftUnionChild(int childIndex, NaryIQTree newUnionChild, ImmutableList<IQTree> initialChildren) { UnionNode newUnionNode = iqFactory.createUnionNode(initialChildren.stream() .flatMap(c -> c.getVariables().stream()) .collect(ImmutableCollectors.toSet())); return iqFactory.createNaryIQTree(newUnionNode, newUnionChild.getChildren().stream() .map(unionGrandChild -> createJoinSubtree(childIndex, unionGrandChild, initialChildren)) .collect(ImmutableCollectors.toList())); }
private ImmutableCollection<Collection<ExtensionalDataNode>> groupDataNodesPerConstraint( FunctionalDependency constraint, ImmutableCollection<ExtensionalDataNode> initialNodes) { ImmutableList<Integer> constraintDeterminantIndexes = constraint.getDeterminants().stream() .map(Attribute::getIndex) .collect(ImmutableCollectors.toList()); ImmutableMultimap<ImmutableList<VariableOrGroundTerm>, ExtensionalDataNode> nodeMultiMap = initialNodes.stream() .collect(ImmutableCollectors.toMultimap( n -> extractDeterminantArguments(n.getProjectionAtom(), constraintDeterminantIndexes), n -> n)); return nodeMultiMap.asMap().values(); }
@Override public ImmutableSet<Variable> getRequiredVariables(IntermediateQuery query) { ImmutableMultiset<Variable> childrenVariableBag = query.getChildren(this).stream() .flatMap(c -> query.getVariables(c).stream()) .collect(ImmutableCollectors.toMultiset()); Stream<Variable> cooccuringVariableStream = childrenVariableBag.entrySet().stream() .filter(e -> e.getCount() > 1) .map(Multiset.Entry::getElement); return Stream.concat(cooccuringVariableStream, getLocallyRequiredVariables().stream()) .collect(ImmutableCollectors.toSet()); }
private ImmutableMultimap<RelationPredicate, ImmutableList<Integer>> extractUniqueConstraints() { return getDatabaseRelations().stream() .flatMap(this::extractUniqueConstraintsFromRelation) .collect(ImmutableCollectors.toMultimap()); }
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()); }
public static UriTemplateMatcher merge(Stream<UriTemplateMatcher> uriTemplateMatchers, TermFactory termFactory) { ImmutableMap<Pattern, Collection<ImmutableFunctionalTerm>> pattern2Terms = uriTemplateMatchers .flatMap(m -> m.getMap().entrySet().stream()) .collect(ImmutableCollectors.toMultimap()) .asMap(); ImmutableMap<Pattern, ImmutableFunctionalTerm> pattern2Term = pattern2Terms.entrySet().stream() .collect(ImmutableCollectors.toMap( e -> e.getKey(), e -> flatten(e.getKey(), e.getValue()) )); UriTemplateMatcher uriTemplateMatcher = new UriTemplateMatcher(termFactory); uriTemplateMatcher.uriTemplateMatcher.putAll(pattern2Term); return uriTemplateMatcher; }
private ImmutableCollection<Collection<DataNode>> groupDataNodesPerConstraint( FunctionalDependency constraint, ImmutableCollection<DataNode> initialNodes) { ImmutableList<Integer> constraintDeterminantIndexes = constraint.getDeterminants().stream() .map(Attribute::getIndex) .collect(ImmutableCollectors.toList()); ImmutableMultimap<ImmutableList<VariableOrGroundTerm>, DataNode> nodeMultiMap = initialNodes.stream() .collect(ImmutableCollectors.toMultimap( n -> extractDeterminantArguments(n.getProjectionAtom(), constraintDeterminantIndexes), n -> n)); return nodeMultiMap.asMap().values(); }
@Override public ImmutableSet<Variable> getRequiredVariables(IntermediateQuery query) { ImmutableMultiset<Variable> childrenVariableBag = query.getChildren(this).stream() .flatMap(c -> query.getVariables(c).stream()) .collect(ImmutableCollectors.toMultiset()); Stream<Variable> cooccuringVariableStream = childrenVariableBag.entrySet().stream() .filter(e -> e.getCount() > 1) .map(Multiset.Entry::getElement); return Stream.concat(cooccuringVariableStream, getLocallyRequiredVariables().stream()) .collect(ImmutableCollectors.toSet()); } }
private ImmutableMultimap<AtomPredicate, ImmutableList<Integer>> extractUniqueConstraints() { Map<Predicate, AtomPredicate> predicateCache = new HashMap<>(); return getDatabaseRelations().stream() .flatMap(relation -> extractUniqueConstraintsFromRelation(relation, predicateCache)) .collect(ImmutableCollectors.toMultimap()); }
@Override public Mapping rewrite(Mapping mapping) { if (!enabled) return mapping; ImmutableTable<RDFAtomPredicate, IRI, IQ> mappingUpdate = mapping.getRDFAtomPredicates().stream() .flatMap(p -> mapping.getRDFPropertyDefinition(p, OWL.SAME_AS) .map(sameAsDef -> completeSameAsDefinition(sameAsDef, p)) .map(sameAsDef -> Tables.immutableCell(p, OWL.SAME_AS, sameAsDef)) .map(Stream::of) .orElseGet(Stream::empty)) .collect(ImmutableCollectors.toTable()); return mapping.update(mappingUpdate, ImmutableTable.of()); }
private ImmutableList<String> getTableDefs(List<Function> atoms, AliasIndex index, String indent) { return atoms.stream() .map(a -> getTableDefinition(a, index, indent)) .filter(d -> d != null) .collect(ImmutableCollectors.toList()); }
@Override public Optional<ImmutableSubstitution<ImmutableTerm>> getOptionalSubstitution() { return Optional.of(substitutionMap.getMergedBindings().collect(ImmutableCollectors.toMap())).filter(m -> !m.isEmpty()) .map(SUBSTITUTION_FACTORY::getSubstitution); }
private ImmutableSet<Variable> getNullableVariables() { if (nullableVariables == null) nullableVariables = nullableGroups.stream() .flatMap(Collection::stream) .collect(ImmutableCollectors.toSet()); return nullableVariables; }
public static UriTemplateMatcher merge(Stream<UriTemplateMatcher> uriTemplateMatchers) { ImmutableMap<Pattern, Collection<ImmutableFunctionalTerm>> pattern2Terms = uriTemplateMatchers .flatMap(m -> m.getMap().entrySet().stream()) .collect(ImmutableCollectors.toMultimap()) .asMap(); ImmutableMap<Pattern, ImmutableFunctionalTerm> pattern2Term = pattern2Terms.entrySet().stream() .collect(ImmutableCollectors.toMap( e -> e.getKey(), e -> flatten(e.getKey(), e.getValue()) )); UriTemplateMatcher uriTemplateMatcher = new UriTemplateMatcher(); uriTemplateMatcher.uriTemplateMatcher.putAll(pattern2Term); return uriTemplateMatcher; }
/** * Predicates not having a DatabaseRelationDefinition are ignored */ private ImmutableMultimap<RelationDefinition, ExtensionalDataNode> extractDataNodeMap(IntermediateQuery query, InnerJoinNode joinNode) { return query.getChildren(joinNode).stream() .filter(c -> c instanceof ExtensionalDataNode) .map(c -> (ExtensionalDataNode) c) .map(c -> Maps.immutableEntry(c.getProjectionAtom().getPredicate().getRelationDefinition(), c)) .collect(ImmutableCollectors.toMultimap()); }