public static DatalogProgram program(Collection<CQIE> rules){ DatalogProgram datalogProgram = DATALOG_FACTORY.getDatalogProgram(); datalogProgram.appendRule(rules); return datalogProgram; }
/** * @param uriTemplateMatcher matches URIs to templates (comes from mappings) * @param iriDictionary maps URIs to their integer identifiers (used only in the Semantic Index mode) * @param termFactory * @param typeFactory * @param datalogFactory * @param immutabilityTools * */ SparqlAlgebraToDatalogTranslator(@Nonnull UriTemplateMatcher uriTemplateMatcher, @Nullable IRIDictionary iriDictionary, AtomFactory atomFactory, TermFactory termFactory, TypeFactory typeFactory, DatalogFactory datalogFactory, ImmutabilityTools immutabilityTools, org.apache.commons.rdf.api.RDF rdfFactory) { this.uriTemplateMatcher = uriTemplateMatcher; this.uriRef = iriDictionary; this.atomFactory = atomFactory; this.termFactory = termFactory; this.typeFactory = typeFactory; this.datalogFactory = datalogFactory; this.immutabilityTools = immutabilityTools; this.program = this.datalogFactory.getDatalogProgram(); this.rdfFactory = rdfFactory; this.valueNull = termFactory.getNullConstant(); }
/** * Translate the swrl_rule * Return a datalog program containing the supported datalog facts * @param rule an SWRLRule * @return DatalogProgram */ public DatalogProgram createDatalog(SWRLRule rule){ rule.accept(this); if (notSupported){ log.warn("Not Supported Translation of: "+ errors); errors.clear(); } DatalogProgram dp = datalogFactory.getDatalogProgram(); dp.appendRule(facts); return dp; }
/** * Translate an intermediate query tree into a Datalog program. * <p> * Each (strict) subquery will be translated as a rule with head Pred(var_1, .., var_n), * where the string for Pred is of the form SUBQUERY_PRED_PREFIX + y, * with y > subqueryCounter. */ @Override public DatalogProgram translate(IntermediateQuery query) { Optional<ImmutableQueryModifiers> optionalModifiers = Optional.of(query.getRootNode()) .filter(r -> r instanceof ConstructionNode) .map(r -> (ConstructionNode)r) .flatMap(ConstructionNode::getOptionalModifiers); // Mutable DatalogProgram dProgram; if (optionalModifiers.isPresent()) { MutableQueryModifiers mutableModifiers = new MutableQueryModifiersImpl(optionalModifiers.get()); dProgram = DATALOG_FACTORY.getDatalogProgram(mutableModifiers); } else { dProgram = DATALOG_FACTORY.getDatalogProgram(); } normalizeIQ(query) .forEach(q -> translate(q, dProgram)); return dProgram; }
/** * Translate an intermediate query tree into a Datalog program. * * Each (strict) subquery will be translated as a rule with head Pred(var_1, .., var_n), * where the string for Pred is of the form SUBQUERY_PRED_PREFIX + y, * with y > subqueryCounter. */ @Override public DatalogProgram translate(IQ initialQuery) { IQ orderLiftedQuery = liftOrderBy(initialQuery); Optional<MutableQueryModifiers> optionalModifiers = extractTopQueryModifiers(orderLiftedQuery); // Mutable DatalogProgram dProgram; if (optionalModifiers.isPresent()){ MutableQueryModifiers mutableModifiers = optionalModifiers.get(); dProgram = datalogFactory.getDatalogProgram(mutableModifiers); } else { dProgram = datalogFactory.getDatalogProgram(); } normalizeIQ(orderLiftedQuery) .forEach(q -> translate(q, dProgram)); // CQIEs are mutable dProgram.getRules().forEach(q -> unfoldJoinTrees(q.getBody())); return dProgram; }
/** * Translate the swrl_rules contained in the ontology * Return a datalog program containing the supported datalog facts * @param onto an OWLOntology * @return DatalogProgram */ public DatalogProgram createDatalog(OWLOntology onto) { for (OWLAxiom axiom: onto.getAxioms()){ if(axiom.getAxiomType().equals(AxiomType.SWRL_RULE)){ SWRLRule rule =(SWRLRule) axiom; rule.accept(this); if (notSupported){ log.warn("Not Supported Translation of: "+ errors); errors.clear(); } } } DatalogProgram dp = datalogFactory.getDatalogProgram(); dp.appendRule(facts); return dp; }
@Override public DatalogProgram getSameAsRewriting(DatalogProgram pr) { if (targetPredicates == null) targetPredicates = SameAsTargets.extract(saturatedMapping); DatalogProgram result = datalogFactory.getDatalogProgram(pr.getQueryModifiers()); for (CQIE q: pr.getRules()) { List<Function> body = new ArrayList<>(q.getBody().size()); for (Function a : q.getBody()) { Function ap = addSameAs(a, result, "sameAs" + (rules++)); body.add(ap); } result.appendRule(datalogFactory.getCQIE(q.getHead(), body)); } return result; }
private IQ preProcess(InternalSparqlQuery translation) throws OntopInvalidInputQueryException, EmptyQueryException { DatalogProgram program = translation.getProgram(); log.debug("Datalog program translated from the SPARQL query: \n{}", program); if(settings.isSameAsInMappingsEnabled()){ program = sameAsRewriter.getSameAsRewriting(program); log.debug("Datalog program after SameAs rewriting \n{}", program); } log.debug("Replacing equivalences..."); DatalogProgram newprogramEq = datalogFactory.getDatalogProgram(program.getQueryModifiers()); for (CQIE query : program.getRules()) { CQIE rule = query.clone(); // EQNormalizer cannot be removed because it is used in NULL propagation in OPTIONAL eqNormalizer.enforceEqualities(rule); newprogramEq.appendRule(rule); } if (newprogramEq.getRules().isEmpty()) throw new OntopInvalidInputQueryException("Error, the translation of the query generated 0 rules. " + "This is not possible for any SELECT query (other queries are not supported by the translator)."); return datalogConverter.convertDatalogProgram(newprogramEq, ImmutableList.of(), translation.getSignature()); }
DatalogProgram programAfterRewriting = datalogFactory.getDatalogProgram(program.getQueryModifiers(), outputRules); IQ convertedIQ = datalogConverter.convertDatalogProgram(programAfterRewriting, ImmutableList.of(), query.getProjectionAtom().getArguments());