public OWLLiteral translate(ValueConstant v) { if (v == null) return null; String value = v.getValue(); if (value == null) { return null; } TermType type = v.getType(); if (!(type instanceof RDFDatatype)) // TODO: throw a proper exception throw new IllegalStateException("A ValueConstant given to OWLAPI must have a RDF datatype"); RDFDatatype datatype = (RDFDatatype) type; if (datatype.getLanguageTag().isPresent()) { return dataFactory.getOWLLiteral(value, datatype.getLanguageTag().get().getFullString()); } else { OWLDatatype owlDatatype = new OWLDatatypeImpl(IRI.create(datatype.getIRI().getIRIString())); if (owlDatatype != null) return dataFactory.getOWLLiteral(value, owlDatatype); else throw new IllegalArgumentException(datatype.toString()); } }
private static boolean isXsdBoolean(Predicate predicate) { return (predicate instanceof DatatypePredicate) && ((DatatypePredicate) predicate).getReturnedType().isA(XSD.BOOLEAN); } }
@Override public RDFDatatype getDatatype(IRI iri) { return datatypeCache.computeIfAbsent( iri, // Non-predefined datatypes cannot be declared as the child of a concrete datatype i -> createSimpleRDFDatatype(i, rdfsLiteralDatatype.getAncestry())); }
@Override public Optional<DatatypePredicate> getOptionalTypePredicate(RDFDatatype type) { if (type.isAbstract()) throw new IllegalArgumentException("The datatype " + type + " is abstract and therefore cannot be constructed"); return Optional.of(type2FunctionSymbolMap .computeIfAbsent( type, t -> t.getLanguageTag() // Lang string .map(tag -> new DatatypePredicateImpl(type, typeFactory.getDatatype(XSD.STRING))) // Other datatypes .orElseGet(() -> new DatatypePredicateImpl(type, type)))); }
private void registerDatatype(RDFDatatype datatype) { datatypeCache.put(datatype.getIRI(), datatype); }
@Override public boolean equals(Object other) { if (other instanceof RDFDatatype) { RDFDatatype otherType = (RDFDatatype) other; return otherType.getLanguageTag() .filter(langTag::equals) .isPresent(); } return false; }
@Override public boolean isA(IRI baseDatatypeIri) { return getAncestry().getTermTypes() .filter(t -> t instanceof RDFDatatype) .map(t -> ((RDFDatatype)t).getIRI()) .anyMatch(baseDatatypeIri::equals); }
@Override public TermType getCommonDenominator(TermType otherTermType) { if (otherTermType instanceof RDFDatatype) { RDFDatatype otherDatatype = ((RDFDatatype) otherTermType); Optional<LanguageTag> otherLanguageTag = otherDatatype.getLanguageTag(); // Common denominator between two lang strings if (otherLanguageTag.isPresent()) return getCommonDenominator(otherLanguageTag.get()); } /* * Other term types --> standard test */ return super.getCommonDenominator(otherTermType); }
private void initDataProperty(ObjectRDFType type1, RDFDatatype type2) { String value = type1.isBlankNode() ? "TRUE" : "FALSE"; String filter = "ISBNODE = " + value + " AND "; String select, insert; if (type2.getLanguageTag().isPresent()) { /* * If the mapping is for something of type Literal we need to add IS * NULL or IS NOT NULL to the language column. IS NOT NULL might be * redundant since we have another stage in Quest where we add IS NOT * NULL for every variable in the head of a mapping. */ LanguageTag languageTag = type2.getLanguageTag().get(); // Hack: use the RDFS Literal table to get the table description RDBMSSIRepositoryManager.TableDescription tableDescription = RDBMSSIRepositoryManager.ATTRIBUTE_TABLE_MAP .get(RDF.LANGSTRING); select = tableDescription.getSELECT("LANG = '" + languageTag.getFullString() + "' AND " + filter); insert = tableDescription.getINSERT("?, ?, ?, ?, " + value); } else { RDBMSSIRepositoryManager.TableDescription tableDescription = RDBMSSIRepositoryManager.ATTRIBUTE_TABLE_MAP .get(type2.getIRI()); select = tableDescription.getSELECT(filter); insert = tableDescription.getINSERT("?, ?, ?, " + value); } createViews(type1, type2, select, insert); }
private Optional<COL_TYPE> extractColType(TermType termType) { if (termType instanceof ObjectRDFType) { COL_TYPE colType = ((ObjectRDFType)termType).isBlankNode() ? BNODE : OBJECT; return Optional.of(colType); } else if (termType instanceof RDFDatatype) { return Optional.of(COL_TYPE.getColType(((RDFDatatype)termType).getIRI())); } else return Optional.empty(); }
private ImmutableList<TargetAtom> constructTargetQuery(ImmutableFunctionalTerm iriTerm, ObjectRDFType type1, RDFTermType type2) { Variable X = termFactory.getVariable("X"); Variable Y = termFactory.getVariable("Y"); ImmutableFunctionalTerm subjectTerm; if (!type1.isBlankNode()) subjectTerm = termFactory.getImmutableUriTemplate(X); else { subjectTerm = termFactory.getImmutableBNodeTemplate(X); } ImmutableFunctionalTerm objectTerm; if (type2 instanceof ObjectRDFType) { objectTerm = ((ObjectRDFType)type2).isBlankNode() ? termFactory.getImmutableBNodeTemplate(Y) : termFactory.getImmutableUriTemplate(Y); } else { RDFDatatype datatype = (RDFDatatype) type2; if (datatype.getLanguageTag().isPresent()) { LanguageTag languageTag = datatype.getLanguageTag().get(); objectTerm = termFactory.getImmutableTypedTerm(Y, languageTag.getFullString()); } else { objectTerm = termFactory.getImmutableTypedTerm(Y, datatype); } } TargetAtom targetAtom = targetAtomFactory.getTripleTargetAtom(subjectTerm,iriTerm,objectTerm); return ImmutableList.of(targetAtom); }
private static boolean isXsdString(Predicate predicate) { return (predicate instanceof DatatypePredicate) && ((DatatypePredicate) predicate).getReturnedType().isA(XSD.STRING); }
private RDFDatatype createLangStringDatatype(String languageTagString) { return LangDatatype.createLangDatatype( new LanguageTagImpl(languageTagString), xsdStringDatatype.getAncestry(), this); } }
/** * TODO: could we have a RDF sub-class of ValueConstant? */ public static Literal getLiteral(ValueConstant literal) { Objects.requireNonNull(literal); TermType type = literal.getType(); if (!(type instanceof RDFDatatype)) // TODO: throw a proper exception throw new IllegalStateException("A ValueConstant given to OWLAPI must have a RDF datatype"); RDFDatatype datatype = (RDFDatatype) type; return datatype.getLanguageTag() .map(lang -> fact.createLiteral(literal.getValue(), lang.getFullString())) .orElseGet(() -> fact.createLiteral(literal.getValue(), fact.createIRI(datatype.getIRI().getIRIString()))); }
return termFactory.getUriTemplateForDatatype(typeFactory.getXsdBooleanDatatype().getIRI().getIRIString());
RDFDatatype datatype = ((DatatypePredicate) predicate).getReturnedType(); return datatype.getLanguageTag()
private boolean isNumeric(ValueConstant constant) { String constantValue = constant.getValue(); RDFDatatype type = typeFactory.getDatatype(rdfFactory.createIRI(constantValue)); return type.isA(OntopInternal.NUMERIC); }
registerDatatype(rdfsLiteralDatatype); numericDatatype = createAbstractNumericTermType(OntopInternal.NUMERIC, rdfsLiteralDatatype.getAncestry()); registerDatatype(numericDatatype); registerDatatype(xsdPositiveIntegerDatatype); xsdBooleanDatatype = createSimpleRDFDatatype(XSD.BOOLEAN, rdfsLiteralDatatype.getAncestry()); registerDatatype(xsdBooleanDatatype); xsdStringDatatype = createSimpleRDFDatatype(XSD.STRING, rdfsLiteralDatatype.getAncestry()); registerDatatype(xsdStringDatatype); defaultUnsupportedDatatype = UnsupportedRDFDatatype.createUnsupportedDatatype(rdfsLiteralDatatype.getAncestry()); xsdTimeDatatype = createSimpleRDFDatatype(XSD.TIME, rdfsLiteralDatatype.getAncestry()); registerDatatype(xsdTimeDatatype); xsdDateDatatype = createSimpleRDFDatatype(XSD.DATE, rdfsLiteralDatatype.getAncestry()); registerDatatype(xsdDateDatatype); xsdDatetimeDatatype = createSimpleRDFDatatype(XSD.DATETIME, rdfsLiteralDatatype.getAncestry()); registerDatatype(xsdDatetimeDatatype); xsdDatetimeStampDatatype = createSimpleRDFDatatype(XSD.DATETIMESTAMP, xsdDatetimeDatatype.getAncestry()); registerDatatype(xsdDatetimeStampDatatype); xsdGYearDatatype = createSimpleRDFDatatype(XSD.GYEAR, rdfsLiteralDatatype.getAncestry()); registerDatatype(xsdGYearDatatype); xsdBase64Datatype = createSimpleRDFDatatype(XSD.BASE64BINARY, rdfsLiteralDatatype.getAncestry(), false); registerDatatype(xsdBase64Datatype);
switch (COL_TYPE.getColType(object.getType().getIRI())) { case LANG_STRING: // -3 stm.setString(2, value); stm.setString(4, object.getType().getLanguageTag().get().getFullString()); break; case STRING: // 1
private Term evalStr(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; Predicate predicate = function.getFunctionSymbol(); Term parameter = function.getTerm(0); if (function.isDataTypeFunction()) { if (isXsdString(predicate) ) { // R: was datatype.equals(OBDAVocabulary.RDFS_LITERAL_URI) return termFactory.getTypedTerm( termFactory.getVariable(parameter.toString()), typeFactory.getXsdStringDatatype()); } else { return termFactory.getTypedTerm( termFactory.getFunctionCast(termFactory.getVariable(parameter.toString()), termFactory.getConstantLiteral(typeFactory.getXsdStringDatatype().getIRI().getIRIString())), typeFactory.getXsdStringDatatype()); } } else if (predicate instanceof URITemplatePredicate) { return termFactory.getTypedTerm(function.clone(), typeFactory.getXsdStringDatatype()); } else if (predicate instanceof BNodePredicate) { return valueNull; } } return term; }