private Optional<ImmutableFunctionalTerm> getFirstFunctionalTerm(TargetAtom targetAtom) { return targetAtom.getSubstitution().getImmutableMap().values().stream() .findFirst() .filter(t -> t instanceof ImmutableFunctionalTerm) .map(t -> (ImmutableFunctionalTerm) t); }
for (TargetAtom atom : body) { String subject, predicate, object = ""; String originalString = atom.getProjectionAtom().getPredicate().toString(); if (isUnary(atom.getProjectionAtom())) { ImmutableTerm subjectTerm = atom.getSubstitutedTerm(0); subject = getDisplayName(subjectTerm, prefixManager); predicate = "a"; ImmutableTerm subjectTerm = atom.getSubstitutedTerm(0); subject = getDisplayName(subjectTerm, prefixManager); ImmutableTerm predicateTerm = atom.getSubstitutedTerm(1); predicate = getDisplayName(predicateTerm, prefixManager); ImmutableTerm objectTerm = atom.getSubstitutedTerm(2); object = getDisplayName(objectTerm, prefixManager); ImmutableTerm subjectTerm = atom.getSubstitutedTerm(0); subject = getDisplayName(subjectTerm, prefixManager); predicate = getAbbreviatedName(originalString, prefixManager, false); predicate = "<" + predicate + ">"; ImmutableTerm objectTerm = atom.getSubstitutedTerm(1); object = getDisplayName(objectTerm, prefixManager);
/** A helper method to check a match */ public static boolean match(String keyword, TargetAtom atom) { return atom.getSubstitutedTerms().stream() .anyMatch(t -> match(keyword, t)); }
if (a.getPredicateIRI() .filter(i -> i.equals(removedIRI)) .isPresent()) { DistinctVariableOnlyDataAtom projectionAtom = a.getProjectionAtom(); RDFAtomPredicate predicate = (RDFAtomPredicate)projectionAtom.getPredicate(); boolean isClass = predicate.getClassIRI(a.getSubstitutedTerms()) .isPresent(); a.getSubstitution().getImmutableMap().entrySet().stream() .map(e -> e.getKey().equals(predicateVariable) ? Maps.immutableEntry(predicateVariable,
boolean isClass = isURIRDFType(m.target.getSubstitutedTerm(1)); ImmutableFunctionalTerm templateAtom = (ImmutableFunctionalTerm)m.target.getSubstitutedTerm(isClass ? 2 : 1); termFactory.getConstantLiteral(getPredicateName(templateAtom.getTerm(0), values))); Variable predicateVariable = m.target.getProjectionAtom().getArguments().get(isClass ? 2 : 1); ImmutableSubstitution<ImmutableTerm> newSubstitution = m.target.getSubstitution() .composeWith(substitutionFactory.getSubstitution(predicateVariable, predicateTerm)); TargetAtom newTarget = m.target.changeSubstitution(newSubstitution);
/** * TODO: describe */ public IQ convertDatalogRule(CQIE datalogRule, Collection<Predicate> tablePredicates, Optional<ImmutableQueryModifiers> optionalModifiers, IntermediateQueryFactory iqFactory) throws DatalogProgram2QueryConverterImpl.InvalidDatalogProgramException { TargetAtom targetAtom = datalogConversionTools.convertFromDatalogDataAtom(datalogRule.getHead()); DistinctVariableOnlyDataAtom projectionAtom = targetAtom.getProjectionAtom(); ConstructionNode topConstructionNode = iqFactory.createConstructionNode(projectionAtom.getVariables(), targetAtom.getSubstitution()); List<Function> bodyAtoms = List.iterableList(datalogRule.getBody()); if (bodyAtoms.isEmpty()) { return createFact(topConstructionNode, optionalModifiers, projectionAtom, iqFactory); } else { return createDefinition(topConstructionNode, optionalModifiers, projectionAtom, tablePredicates, bodyAtoms, iqFactory); } }
.map(targetAtom -> { ImmutableList<ImmutableTerm> terms = targetAtom.getSubstitutedTerms(); RDFAtomPredicate predicate = (RDFAtomPredicate) targetAtom.getProjectionAtom().getPredicate();
Optional<IRI> optionalPredicateIri = atom.getPredicateIRI(); ImmutableList<ImmutableTerm> substitutedTerms = atom.getSubstitutedTerms(); RDFAtomPredicate atomPredicate = (RDFAtomPredicate) atom.getProjectionAtom().getPredicate();
.filter(targetAtom -> { ImmutableTerm propertyTerm = targetAtom.getSubstitutedTerm(1); return !targetAtom.getSubstitutedTerm(2).isGround();
private static IRI extractIRI(TargetAtom targetAtom) { return targetAtom.getPredicateIRI() .orElseThrow(() -> new NoPredicateIRIInTargetAtomException(targetAtom)); }
ImmutableSubstitution<ImmutableTerm> bindings = targetAtom.getSubstitution(); DataAtom dataAtom = bindings.applyToDataAtom(targetAtom.getProjectionAtom()); return datalogConversionTools.createDataNode(iqFactory, dataAtom, tablePredicates);
atom.getProjectionAtom().getPredicate(), atom.getSubstitutedTerms());
ImmutableFunctionalTerm uriTemplate = (ImmutableFunctionalTerm) tquery.get(0).getSubstitutedTerm(0); //URI("..{}..", , ) String subjectTemplate = URITemplates.getUriTemplateString(uriTemplate, prefixmng); Template templs = mfact.createTemplate(subjectTemplate); ImmutableFunctionalTerm predf = (ImmutableFunctionalTerm)func.getSubstitutedTerm(1); ImmutableTerm object = func.getSubstitutedTerm(2);
private ImmutableList<TargetAtom> getNewTargetAtoms(SQLPPTriplesMap formerTriplesMap, IRI removedPredicateIRI, AtomicInteger counter) { return formerTriplesMap.getTargetAtoms().stream() .filter(a -> { if (a.getPredicateIRI() .filter(i -> i.equals(removedPredicateIRI)) .isPresent()) { counter.incrementAndGet(); return false; } return true; }) .collect(ImmutableCollectors.toList()); }
public SQLPPMapping generatePPMapping() { ImmutableList<SQLPPTriplesMap> triplesMaps = ImmutableList.copyOf(triplesMapMap.values()); try { UriTemplateMatcher uriTemplateMatcher = UriTemplateMatcher.create( triplesMaps.stream() .flatMap(ax -> ax.getTargetAtoms().stream()) .flatMap(targetAtom -> targetAtom.getSubstitution().getImmutableMap().values().stream()) .filter(t -> t instanceof ImmutableFunctionalTerm) .map(t -> (ImmutableFunctionalTerm) t), termFactory); return ppMappingFactory.createSQLPreProcessedMapping(triplesMaps, // TODO: give an immutable prefix manager!! specificationFactory.createMetadata(prefixManager, uriTemplateMatcher)); /** * No mapping so should never happen */ } catch(DuplicateMappingException e) { throw new RuntimeException("A DuplicateMappingException has been thrown while no mapping has been given." + "What is going on? Message: " + e.getMessage()); } }
public SQLPPMapping createMappings() { OntopMappingConfiguration defaultConfiguration = OntopMappingConfiguration.defaultBuilder() .build(); SpecificationFactory specificationFactory = defaultConfiguration.getInjector().getInstance(SpecificationFactory.class); PrefixManager prefixManager = specificationFactory.createPrefixManager(ImmutableMap.of()); ImmutableList<SQLPPTriplesMap> mappingAxioms = dataRepository.getMappings(); UriTemplateMatcher uriTemplateMatcher = UriTemplateMatcher.create( mappingAxioms.stream() .flatMap(ax -> ax.getTargetAtoms().stream()) .flatMap(atom -> atom.getSubstitution().getImmutableMap().values().stream()) .filter(t -> t instanceof ImmutableFunctionalTerm) .map(t -> (ImmutableFunctionalTerm) t), termFactory); try { return new SQLPPMappingImpl(mappingAxioms, specificationFactory.createMetadata(prefixManager, uriTemplateMatcher)); } catch (DuplicateMappingException e) { throw new IllegalStateException(e.getMessage()); } } }
private SQLPPMapping parse(R2RMLManager manager) throws DuplicateMappingException, InvalidMappingException { try { //TODO: make the R2RMLManager simpler. ImmutableList<SQLPPTriplesMap> sourceMappings = manager.getMappings(manager.getModel()); UriTemplateMatcher uriTemplateMatcher = UriTemplateMatcher.create( sourceMappings.stream() .flatMap(ax -> ax.getTargetAtoms().stream()) .flatMap(atom -> atom.getSubstitution().getImmutableMap().values().stream()) .filter(t -> t instanceof ImmutableFunctionalTerm) .map(t -> (ImmutableFunctionalTerm) t), termFactory); //TODO: try to extract prefixes from the R2RML mappings PrefixManager prefixManager = specificationFactory.createPrefixManager(ImmutableMap.of()); MappingMetadata mappingMetadata = specificationFactory.createMetadata(prefixManager, uriTemplateMatcher); return ppMappingFactory.createSQLPreProcessedMapping(sourceMappings, mappingMetadata); } catch (InvalidR2RMLMappingException e) { throw new InvalidMappingException(e.getMessage()); } }
mappingAxioms.stream() .flatMap(ax -> ax.getTargetAtoms().stream()) .flatMap(atom -> atom.getSubstitution().getImmutableMap().values().stream()) .filter(t -> t instanceof ImmutableFunctionalTerm) .map(t -> (ImmutableFunctionalTerm) t),