@Override public String getName() { return predicate.getName(); }
@Override public String toString() { return predicate.getName().toString(); }
@Override public boolean isTriplePredicate() { return (arity == 3 && name.equals(QUEST_TRIPLE_PRED.getName())); }
private void checkSignature(Datatype desc) { Predicate pred = desc.getPredicate(); if (!OntologyImpl.OWL2QLDatatypes.containsKey(pred.getName())) throw new IllegalArgumentException(DATATYPE_NOT_FOUND + pred); }
/** * special constructor for creating the inverse of an object property * (this constructor is never applied to the top and bottom properties) * * @param p * @param inverseProperty */ private ObjectPropertyExpressionImpl(Predicate p, ObjectPropertyExpressionImpl inverseProperty) { this.predicate = p; this.isInverse = true; // always inverted this.isTop = false; // cannot be the top property this.isBottom = false; // cannot be the bottom property this.inverseProperty = inverseProperty; // always inverted this.string = new StringBuilder().append(predicate.getName()).append("^-").toString(); this.domain = new ObjectSomeValuesFromImpl(this); }
protected AtomPredicateImpl(Predicate datalogPredicate) { super(datalogPredicate.getName(), datalogPredicate.getArity(), datalogPredicate.getTypes() ); if (datalogPredicate instanceof BuiltinPredicate) { throw new IllegalArgumentException("The predicate must corresponds to a data atom!"); } } }
/** * * @param predicate a predicate-name rendering of a possibly qualified table name * @return */ @Deprecated public RelationID createRelationFromPredicateName(QuotedIDFactory idfac, Predicate predicate) { String s = predicate.getName(); // ROMAN (7 Oct 2015): a better way of splitting is probably needed here // String[] names = s.split("\\."); int position = s.indexOf('.'); if (position == -1) return RelationID.createRelationIdFromDatabaseRecord(idfac, null, s); else { return RelationID.createRelationIdFromDatabaseRecord(idfac, s.substring(0, position), s.substring(position + 1, s.length())); } } }
/** * * @param predicate a predicate-name rendering of a possibly qualified table name * @return */ public static RelationID createRelationFromPredicateName(QuotedIDFactory idfac, Predicate predicate) { String s = predicate.getName(); // ROMAN (7 Oct 2015): a better way of splitting is probably needed here // String[] names = s.split("\\."); int position = s.indexOf('.'); if (position == -1) return RelationID.createRelationIdFromDatabaseRecord(idfac, null, s); else { return RelationID.createRelationIdFromDatabaseRecord(idfac, s.substring(0, position), s.substring(position + 1, s.length())); } } }
/** * Produces a map from datatypeProperty to corresponding datatype according to the ontology (the datatype may * be inferred). * This is a rewriting of method: * it.unibz.inf.ontop.owlrefplatform.core.mappingprocessing.MappingDataTypeRepair#getDataTypeFromOntology * from Ontop v 1.18.1 */ private ImmutableMultimap<String, Datatype> computeDataTypeMap(ClassifiedTBox reasoner) { // TODO: switch to guava > 2.1, and replace by Streams.stream(iterable) return StreamSupport.stream(reasoner.dataRangesDAG().spliterator(), false) .flatMap(n -> getPartialPredicateToDatatypeMap(n, reasoner).entrySet().stream()) .collect(ImmutableCollectors.toMultimap( e -> e.getKey().getName(), Map.Entry::getValue)); }
/*** * Creates mappings with heads as "triple(x,y,z)" from mappings with binary * and unary atoms" * * TODO: clean it */ private static ImmutableList<CQIE> generateTripleMappings(ImmutableSet<CQIE> saturatedRules) { return saturatedRules.stream() .filter(r -> !r.getHead().getFunctionSymbol().getName().startsWith(DATALOG_FACTORY.getSubqueryPredicatePrefix())) .map(r -> generateTripleMapping(r)) .collect(ImmutableCollectors.toList()); }
private int getDataType(Term term) { if (term instanceof Function) { Function f = (Function) term; if (f.isDataTypeFunction()) { Predicate p = f.getFunctionSymbol(); COL_TYPE type = TYPE_FACTORY.getDatatype(p.getName()).get(); return jdbcTypeMapper.getSQLType(type); } // return varchar for unknown return Types.VARCHAR; } else if (term instanceof Variable) { throw new RuntimeException("Cannot return the SQL type for: " + term); } else if (term.equals(TermConstants.FALSE) || term.equals(TermConstants.TRUE)) { return Types.BOOLEAN; } return Types.VARCHAR; }
private static String displayDatatypeFunction(ImmutableFunctionalTerm function, Predicate functionSymbol, String fname, PrefixManager prefixManager) { StringBuilder sb = new StringBuilder(); // Language tag case if (functionSymbol.getName().equals(RDF.LANGSTRING.getIRIString())) { // with the language tag ImmutableTerm var = function.getTerms().get(0); ImmutableTerm lang = function.getTerms().get(1); sb.append(getDisplayName(var, prefixManager)); sb.append("@"); if (lang instanceof ValueConstant) { // Don't pass this to getDisplayName() because // language constant is not written as @"lang-tag" sb.append(((ValueConstant) lang).getValue()); } else { sb.append(getDisplayName(lang, prefixManager)); } } else { // for the other data types ImmutableTerm var = function.getTerms().get(0); sb.append(getDisplayName(var, prefixManager)); sb.append("^^"); sb.append(fname); } return sb.toString(); }
/** * add the inverse of the same as present in the mapping */ public static ImmutableList<CQIE> addSameAsInverse(ImmutableList<CQIE> mappingRules) { Stream<CQIE> newRuleStream = mappingRules.stream() // the targets are already split. We have only one target atom .filter(r -> r.getHead().getFunctionSymbol().getName().equals(IriConstants.SAME_AS)) .map(r -> { Function head = r.getHead(); Function inversedHead = TERM_FACTORY.getFunction(head.getFunctionSymbol(), head.getTerm(1), head.getTerm(0)); return DATALOG_FACTORY.getCQIE(inversedHead, new ArrayList<>(r.getBody())); }); return Stream.concat(mappingRules.stream(), newRuleStream) .collect(ImmutableCollectors.toList()); } }
public static Set<OWLDeclarationAxiom> extractDeclarationAxioms(OWLOntologyManager manager, Stream<? extends Function> targetAtoms) { OWLDataFactory dataFactory = manager.getOWLDataFactory(); Set<OWLDeclarationAxiom> declarationAxioms = new HashSet<>(); targetAtoms.forEach(f -> { IRI iri = IRI.create(f.getFunctionSymbol().getName()); final OWLEntity entity; if (f.getArity() == 1) { entity = dataFactory.getOWLClass(iri); } else { Predicate.COL_TYPE secondArgType = f.getFunctionSymbol().getType(1); if ((secondArgType != null) && secondArgType.equals(Predicate.COL_TYPE.OBJECT)) { entity = dataFactory.getOWLObjectProperty(iri); } else { entity = dataFactory.getOWLDataProperty(iri); } } declarationAxioms.add(dataFactory.getOWLDeclarationAxiom(entity)); }); return declarationAxioms; }
private static Statement createStatement(AnnotationAssertion assertion) { Constant constant = assertion.getValue(); if (constant instanceof ValueConstant) { return fact.createStatement(getResource(assertion.getSubject()), createURI(assertion.getProperty().getPredicate().getName()), getLiteral((ValueConstant) constant)); } else if (constant instanceof ObjectConstant) { return fact.createStatement(getResource(assertion.getSubject()), createURI(assertion.getProperty().getPredicate().getName()), getResource((ObjectConstant) constant)); } else { throw new RuntimeException("Unsupported constant for an annotation property!" + constant); } }
private static Statement createStatement(ClassAssertion assertion) { return fact.createStatement(getResource(assertion.getIndividual()), createURI(IriConstants.RDF_TYPE), createURI(assertion.getConcept().getPredicate().getName())); } }
private static Statement createStatement(DataPropertyAssertion assertion) { return fact.createStatement(getResource(assertion.getSubject()), createURI(assertion.getProperty().getPredicate().getName()), getLiteral(assertion.getValue()) ); }
private static Statement createStatement(ObjectPropertyAssertion assertion) { return fact.createStatement(getResource(assertion.getSubject()), createURI(assertion.getProperty().getPredicate().getName()), getResource(assertion.getObject())); }
private static CQIE generateTripleMapping(CQIE rule) { Function newhead; Function currenthead = rule.getHead(); if (currenthead.getArity() == 1) { // head is Class(x) Forming head as triple(x,uri(rdf:type), uri(Class)) Function rdfTypeConstant = TERM_FACTORY.getUriTemplate(TERM_FACTORY.getConstantLiteral(IriConstants.RDF_TYPE)); String classname = currenthead.getFunctionSymbol().getName(); Term classConstant = TERM_FACTORY.getUriTemplate(TERM_FACTORY.getConstantLiteral(classname)); newhead = ATOM_FACTORY.getTripleAtom(currenthead.getTerm(0), rdfTypeConstant, classConstant); } else if (currenthead.getArity() == 2) { // head is Property(x,y) Forming head as triple(x,uri(Property), y) String propname = currenthead.getFunctionSymbol().getName(); Function propConstant = TERM_FACTORY.getUriTemplate(TERM_FACTORY.getConstantLiteral(propname)); newhead = ATOM_FACTORY.getTripleAtom(currenthead.getTerm(0), propConstant, currenthead.getTerm(1)); } else { // head is triple(x,uri(Property),y) newhead = (Function) currenthead.clone(); } return DATALOG_FACTORY.getCQIE(newhead, rule.getBody()); } }