@Override public boolean equals(Object other) { if (other instanceof LanguageTag) { return fullString.equals(((LanguageTag) other).getFullString()); } return false; }
@Override public boolean equals(Object other) { if (other instanceof LanguageTag) { return fullString.equals(((LanguageTag) other).getFullString()); } return false; }
@Override public String toString() { return super.toString() + "@" + langTag.getFullString(); }
private String getLangColumnForSELECT(Term ht, AliasIndex index, Optional<TermType> optionalTermType) { if (ht instanceof Variable) { return index.getLangColumn((Variable) ht) .map(QualifiedAttributeID::getSQLRendering) .orElse(sqladapter.getNullForLang()); } else { return optionalTermType .filter(t -> t instanceof RDFDatatype) .map(t -> (RDFDatatype)t) .flatMap(RDFDatatype::getLanguageTag) .map(tag -> sqladapter.getSQLLexicalFormString(tag.getFullString())) .orElseGet(sqladapter::getNullForLang); } }
private String getLangColumnForSELECT(Term ht, AliasIndex index, Optional<TermType> optionalTermType) { if (ht instanceof Variable) { return index.getLangColumn((Variable) ht) .map(QualifiedAttributeID::getSQLRendering) .orElse(sqladapter.getNullForLang()); } else { return optionalTermType .filter(t -> t.getColType() == LANG_STRING) .map(t -> t.getLanguageTagConstant() .map(tag -> "'" + tag.getFullString() + "'") .orElseGet(() -> t.getLanguageTagTerm() .map(tag -> getSQLString(tag, index, false)) .orElseThrow(() -> new IllegalStateException( "Inconsistent term type: the language tag must be defined for any LANG_STRING")))) .orElse(sqladapter.getNullForLang()); } }
private String getLangColumnForSELECT(Term ht, String signatureVarName, QueryAliasIndex index, Set<String> sqlVariableNames, Optional<TermType> optionalTermType) { /** * Creates a variable name that fits to the restrictions of the SQL dialect. */ String langVariableName = sqladapter.nameTopVariable(signatureVarName, LANG_SUFFIX, sqlVariableNames); sqlVariableNames.add(langVariableName); final String lang; if (ht instanceof Variable) { lang = getLangFromVariable((Variable) ht, index); } else { lang = optionalTermType .filter(t -> t.getColType() == LITERAL_LANG) .map(t -> t.getLanguageTagConstant() .map(tag -> "'" + tag.getFullString() + "'") .orElseGet(() -> t.getLanguageTagTerm() .map(tag -> getSQLString(tag, index, false)) .orElseThrow(() -> new IllegalStateException( "Inconsistent term type: the language tag must be defined " + "for any LITERAL_LANG")))) .orElse("NULL"); } return String.format(LANG_STR, lang, langVariableName); }
/** * 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()))); }
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 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); }
case LANG_STRING: // -3 stm.setString(2, value); stm.setString(4, object.getType().getLanguageTag().get().getFullString()); break; case STRING: // 1
termFactory.getConstantLiteral(tag.getFullString(), XSD.STRING), XSD.STRING)) .orElse(emptyString);
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); }
Optional<LanguageTag> optionalLangTag = objectDatatype.getLanguageTag(); if (optionalLangTag.isPresent()) { obm.setLanguageTag(optionalLangTag.get().getFullString()); Optional<LanguageTag> optionalLangTag = objectDatatype.getLanguageTag(); if (optionalLangTag.isPresent()) { obm.setLanguageTag(optionalLangTag.get().getFullString());
termFactory.getConstantLiteral(s.getIRI().getIRIString())), propertyIRI, termFactory.getTypedTerm(termFactory.getConstantLiteral(o.getValue()), lang.getFullString()))) .orElseGet(() -> atomFactory.getMutableTripleHeadAtom(termFactory.getUriTemplate( termFactory.getConstantLiteral(s.getIRI().getIRIString())), termFactory.getConstantLiteral(s.getIRI().getIRIString())), propertyIRI, termFactory.getTypedTerm(termFactory.getConstantLiteral(o.getValue()), lang.getFullString()))) .orElseGet(() -> atomFactory.getMutableTripleHeadAtom(termFactory.getUriTemplate( termFactory.getConstantLiteral(s.getIRI().getIRIString())),