@Override protected Optional<IQ> getDefinition(IntensionalDataNode dataNode) { return Optional.ofNullable(map.get(dataNode.getProjectionAtom().getPredicate())); }
protected static ImmutableMultimap<RelationPredicate, ExtensionalDataNode> extractDataNodes(ImmutableList<QueryNode> siblings) { ImmutableMultimap.Builder<RelationPredicate, ExtensionalDataNode> mapBuilder = ImmutableMultimap.builder(); for (QueryNode node : siblings) { if (node instanceof ExtensionalDataNode) { ExtensionalDataNode dataNode = (ExtensionalDataNode) node; mapBuilder.put(dataNode.getProjectionAtom().getPredicate(), dataNode); } } return mapBuilder.build(); }
private RDFAtomPredicate getRDFAtomPredicate(DataAtom atom){ return Optional.of(atom.getPredicate()) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .orElseThrow(() -> new CanonicalTransformerException(RDFAtomPredicate.class.getName() + " expected")); }
protected static ImmutableMultimap<AtomPredicate, DataNode> extractDataNodes(ImmutableList<QueryNode> siblings) { ImmutableMultimap.Builder<AtomPredicate, DataNode> mapBuilder = ImmutableMultimap.builder(); for (QueryNode node : siblings) { if (node instanceof DataNode) { DataNode dataNode = (DataNode) node; mapBuilder.put(dataNode.getProjectionAtom().getPredicate(), dataNode); } } return mapBuilder.build(); }
private Optional<IRI> getPropertyIRI(DataAtom atom) { AtomPredicate atomPredicate = atom.getPredicate(); return Optional.of(atomPredicate) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .flatMap(p -> p.getPropertyIRI(atom.getArguments())); }
private static boolean extendHomomorphism(Map<Variable, VariableOrGroundTerm> map, DataAtom from, DataAtom to) { return from.getPredicate().equals(to.getPredicate()) && extendHomomorphism(map, from.getArguments(), to.getArguments()); }
@Override public boolean hasSamePredicateAndArity(DataAtom otherAtom) { if (!predicate.equals(otherAtom.getPredicate())) return false; if (getEffectiveArity() != otherAtom.getEffectiveArity()) return false; return true; }
/** * 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()); }
private <P extends AtomPredicate> DataAtom<P> replaceVars(DataAtom<P> projectionAtom, ImmutableList<Optional<Variable>> replacements) { Iterator<Optional<Variable>> it = replacements.iterator(); return atomFactory.getDataAtom( projectionAtom.getPredicate(), projectionAtom.getArguments().stream() .map(a -> { Optional<Variable> r = it.next(); return r.isPresent() ? r.get() : a; }) .collect(ImmutableCollectors.toList()) ); }
private DataAtom renameDataAtom(DataAtom atom) { ImmutableList.Builder<VariableOrGroundTerm> argListBuilder = ImmutableList.builder(); for (VariableOrGroundTerm term : atom.getArguments()) { argListBuilder.add(renamingSubstitution.applyToTerm(term)); } return ATOM_FACTORY.getDataAtom(atom.getPredicate(), argListBuilder.build()); }
@Override public boolean isVariableNullable(IntermediateQuery query, Variable variable) { if (!getVariables().contains(variable)) throw new IllegalArgumentException("The variable " + variable + " is not projected by " + this); DataAtom<RelationPredicate> atom = getProjectionAtom(); RelationDefinition relation = atom.getPredicate().getRelationDefinition(); ImmutableList<? extends VariableOrGroundTerm> arguments = atom.getArguments(); // NB: DB column indexes start at 1. return IntStream.range(1, arguments.size() + 1) .filter(i -> arguments.get(i - 1).equals(variable)) .mapToObj(relation::getAttribute) .allMatch(Attribute::canNull); }
/** * TODO: explain */ public DataNode createDataNode(IntermediateQueryFactory iqFactory, DataAtom dataAtom, Collection<Predicate> tablePredicates) { if (tablePredicates.contains(dataAtom.getPredicate())) { return iqFactory.createExtensionalDataNode(dataAtom); } return iqFactory.createIntensionalDataNode(dataAtom); }
/** * TODO: explain */ public static DataNode createDataNode(IntermediateQueryFactory iqFactory, DataAtom dataAtom, Collection<Predicate> tablePredicates) { if (tablePredicates.contains(dataAtom.getPredicate())) { return iqFactory.createExtensionalDataNode(dataAtom); } return iqFactory.createIntensionalDataNode(dataAtom); }
private DataAtom renameDataAtom(DataAtom<? extends AtomPredicate> atom) { ImmutableList.Builder<VariableOrGroundTerm> argListBuilder = ImmutableList.builder(); for (VariableOrGroundTerm term : atom.getArguments()) { argListBuilder.add(renamingSubstitution.applyToTerm(term)); } return atomFactory.getDataAtom(atom.getPredicate(), argListBuilder.build()); }
@Override protected Optional<IQ> getDefinition(IntensionalDataNode dataNode) { if (getPropertyIRI(dataNode.getProjectionAtom()) .filter(i -> i.equals(Ontop.CANONICAL_IRI)) .isPresent()) { return Optional.of(definition); } throw new UnexpectedPredicateException(dataNode.getProjectionAtom().getPredicate()); }
public Function convertToMutableFunction(DataAtom dataAtom) { return convertToMutableFunction(dataAtom.getPredicate(), dataAtom.getArguments()); }
protected DataNode generateDataNode(DataNode formerDataNode, ImmutableList<VariableOrGroundTerm> arguments) { DataAtom dataAtom = ATOM_FACTORY.getDataAtom(formerDataNode.getProjectionAtom().getPredicate(), arguments); if (formerDataNode instanceof ExtensionalDataNode) { return iqFactory.createExtensionalDataNode(dataAtom); } else if (formerDataNode instanceof IntensionalDataNode) { return iqFactory.createIntensionalDataNode(dataAtom); } else { throw new RuntimeException("Transformation of a data node of type " + formerDataNode.getClass() + " is not supported yet"); } }
private static ImmutableSubstitution<VariableOrGroundTerm> extractSubstitution(DistinctVariableOnlyDataAtom sourceAtom, DataAtom targetAtom) { if (!sourceAtom.getPredicate().equals(targetAtom.getPredicate())) { throw new IllegalStateException("Incompatible predicates"); } else if (sourceAtom.getEffectiveArity() != targetAtom.getEffectiveArity()) { throw new IllegalStateException("Different arities"); } ImmutableMap<Variable, VariableOrGroundTerm> newMap = FunctionalTools.zip( sourceAtom.getArguments(), (ImmutableList<VariableOrGroundTerm>) targetAtom.getArguments()).stream() .collect(ImmutableCollectors.toMap()); return SUBSTITUTION_FACTORY.getSubstitution(newMap); }
private ImmutableSubstitution<VariableOrGroundTerm> extractSubstitution(DistinctVariableOnlyDataAtom sourceAtom, DataAtom targetAtom) { if (!sourceAtom.getPredicate().equals(targetAtom.getPredicate())) { throw new IllegalStateException("Incompatible predicates"); } else if (sourceAtom.getEffectiveArity() != targetAtom.getEffectiveArity()) { throw new IllegalStateException("Different arities"); } ImmutableMap<Variable, VariableOrGroundTerm> newMap = FunctionalTools.zip( sourceAtom.getArguments(), (ImmutableList<VariableOrGroundTerm>) targetAtom.getArguments()).stream() .collect(ImmutableCollectors.toMap()); return substitutionFactory.getSubstitution(newMap); } }
@Override public DataAtom applyToDataAtom(DataAtom atom) throws ConversionException { ImmutableList<? extends ImmutableTerm> newArguments = apply(atom.getArguments()); for (ImmutableTerm subTerm : newArguments) { if (!(subTerm instanceof VariableOrGroundTerm)) throw new ConversionException("The sub-term: " + subTerm + " is not a VariableOrGroundTerm"); } return atomFactory.getDataAtom(atom.getPredicate(), (ImmutableList<? extends VariableOrGroundTerm>) newArguments); }