public static Function literal(Term term){ return TERM_FACTORY.getTypedTerm(term, Predicate.COL_TYPE.STRING); }
private Term typeTerm(String text, COL_TYPE col_type) { ValueConstant integerConstant = TERM_FACTORY.getConstantLiteral(text, COL_TYPE.LITERAL); return TERM_FACTORY.getTypedTerm(integerConstant, col_type); }
@Override public Term visitLiteral(LiteralContext ctx) { StringLiteralContext slc = ctx.stringLiteral(); if (slc != null) { Term literal = visitStringLiteral(slc); LanguageTagContext lc = ctx.languageTag(); //if variable we cannot assign a datatype yet if (literal instanceof Variable) { return TERM_FACTORY.getTypedTerm(literal, COL_TYPE.STRING); } if (lc != null) { return TERM_FACTORY.getTypedTerm(literal, visitLanguageTag(lc)); } return TERM_FACTORY.getTypedTerm(literal, COL_TYPE.STRING); } return (Term) visitChildren(ctx); }
@Override public Term visitTypedLiteral(TypedLiteralContext ctx) { Term stringValue = visitStringLiteral(ctx.stringLiteral()); String iriRef = visitIri(ctx.iri()); Optional<COL_TYPE> type = TYPE_FACTORY.getDatatype(iriRef); if (type.isPresent()) { return TERM_FACTORY.getTypedTerm(stringValue, type.get()); } throw new RuntimeException("Unsupported datatype: " + iriRef); }
@Override public Function visitVariableLiteral_2(VariableLiteral_2Context ctx) { Variable var = visitVariable(ctx.variable()); String iri = visitIri(ctx.iri()); Optional<COL_TYPE> type = TYPE_FACTORY.getDatatype(iri); if (type.isPresent()) { return TERM_FACTORY.getTypedTerm(var, type.get()); } throw new RuntimeException("ERROR. A mapping involves an unsupported datatype. \nOffending datatype:" + iri); }
@Override public Function visitVariableLiteral_1(VariableLiteral_1Context ctx) { return TERM_FACTORY.getTypedTerm(visitVariable(ctx.variable()), visitLanguageTag(ctx.languageTag())); }
TERM_FACTORY.getTypedTerm( term, inferredType.get().getColType() atom.setTerm(position, TERM_FACTORY.getTypedTerm(term, Predicate.COL_TYPE.STRING)); } else { throw new UnknownDatatypeException("Impossible to determine the expected datatype for the operation " + castTerm + "\n" +
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 (TYPE_FACTORY.isString(predicate) ) { // R: was datatype.equals(OBDAVocabulary.RDFS_LITERAL_URI) return TERM_FACTORY.getTypedTerm( TERM_FACTORY.getVariable(parameter.toString()), COL_TYPE.STRING); } else { return TERM_FACTORY.getTypedTerm( TERM_FACTORY.getFunctionCast(TERM_FACTORY.getVariable(parameter.toString()), TERM_FACTORY.getConstantLiteral(TYPE_FACTORY.getDatatypeURI(COL_TYPE.STRING).stringValue())), COL_TYPE.STRING); } } else if (predicate instanceof URITemplatePredicate) { return TERM_FACTORY.getTypedTerm(function.clone(), COL_TYPE.STRING); } else if (predicate instanceof BNodePredicate) { return TermConstants.NULL; } } return term; }
Term newTerm; RDFDatatype type = getDataType(termOccurenceIndex, variable); newTerm = termFactory.getTypedTerm(variable, type); log.info("Datatype "+type+" for the value " + variable + " of the property " + atom + " has been " + "inferred " + atom.setTerm(position, newTerm); } else if (term instanceof ValueConstant) { Term newTerm = termFactory.getTypedTerm(term, ((ValueConstant) term).getType()); atom.setTerm(position, newTerm); } else {
Function emptyString = termFactory.getTypedTerm( termFactory.getConstantLiteral("", XSD.STRING), XSD.STRING); .map(tag -> termFactory.getTypedTerm( termFactory.getConstantLiteral(tag.getFullString(), XSD.STRING), XSD.STRING))
termFactory.getTypedTerm( term, atom.setTerm(position, termFactory.getTypedTerm(term, typeFactory.getXsdStringDatatype())); } else { throw new UnknownDatatypeException("Impossible to determine the expected datatype for the operation " + castTerm + "\n" +
Term emptyconstant = TERM_FACTORY.getTypedTerm(TERM_FACTORY.getConstantLiteral("", COL_TYPE.STRING), COL_TYPE.STRING); Term parameter = function.getTerm(1); if (parameter instanceof Variable) { return TERM_FACTORY.getTypedTerm(parameter.clone(), COL_TYPE.STRING); return TERM_FACTORY.getTypedTerm( TERM_FACTORY.getConstantLiteral(((Constant) parameter).getValue(),COL_TYPE.STRING), COL_TYPE.STRING);
Term newTerm; Predicate.COL_TYPE type = getDataType(termOccurenceIndex, variable); newTerm = TERM_FACTORY.getTypedTerm(variable, type); log.info("Datatype "+type+" for the value " + variable + " of the property " + predicate + " has been " + "inferred " + atom.setTerm(position, newTerm); } else if (term instanceof ValueConstant) { Term newTerm = TERM_FACTORY.getTypedTerm(term, ((ValueConstant) term).getType()); atom.setTerm(position, newTerm); } else {
if (newterm == TermConstants.FALSE) { terms.set(i, TERM_FACTORY.getTypedTerm(TermConstants.FALSE, COL_TYPE.BOOLEAN)); } else if (newterm == TermConstants.TRUE) {
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; }
if (newterm == valueFalse) { terms.set(i, termFactory.getTypedTerm(valueFalse, typeFactory.getXsdBooleanDatatype())); } else if (newterm == valueTrue) {
private Term getTermForLiteral(Literal literal) throws OntopUnsupportedInputQueryException { IRI typeURI = literal.getDatatype(); String value = literal.getLabel(); Optional<String> lang = literal.getLanguage(); if (lang.isPresent()) { // TODO: use a string lexical type instead return termFactory.getTypedTerm(termFactory.getConstantLiteral(value, typeFactory.getXsdStringDatatype()), lang.get()); } else { RDFDatatype type; /* * default data type is xsd:string */ if (typeURI == null) { type = typeFactory.getXsdStringDatatype(); } else { type = typeFactory.getDatatype(rdfFactory.createIRI(typeURI.stringValue())); } if (type == null) // ROMAN (27 June 2016): type1 in open-eq-05 test would not be supported in OWL // the actual value is LOST here return termFactory.getUriTemplateForDatatype(typeURI.stringValue()); // old strict version: // throw new RuntimeException("Unsupported datatype: " + typeURI); // check if the value is (lexically) correct for the specified datatype if (!XMLDatatypeUtil.isValidValue(value, typeURI)) throw new OntopUnsupportedInputQueryException("Invalid lexical form for datatype. Found: " + value); Term constant = termFactory.getConstantLiteral(value, type); return termFactory.getTypedTerm(constant, type); } }
head = TERM_FACTORY.getFunction(p, TERM_FACTORY.getUriTemplate( TERM_FACTORY.getConstantLiteral(s.getURI())), TERM_FACTORY.getTypedTerm(TERM_FACTORY.getConstantLiteral(o.getValue()), o.getLanguage())); } else { TERM_FACTORY.getConstantLiteral(s.getURI())), TERM_FACTORY.getTypedTerm(o, o.getType())); head = TERM_FACTORY.getFunction(p, TERM_FACTORY.getUriTemplate( TERM_FACTORY.getConstantLiteral(s.getURI())), TERM_FACTORY.getTypedTerm(TERM_FACTORY.getConstantLiteral(o.getValue()), o.getLanguage())); } else { TERM_FACTORY.getConstantLiteral(s.getURI())), TERM_FACTORY.getTypedTerm(o, o.getType()));
termFactory.getConstantLiteral(s.getIRI().getIRIString())), propertyIRI, termFactory.getTypedTerm(termFactory.getConstantLiteral(o.getValue()), lang.getFullString()))) .orElseGet(() -> atomFactory.getMutableTripleHeadAtom(termFactory.getUriTemplate( termFactory.getConstantLiteral(s.getIRI().getIRIString())), propertyIRI, termFactory.getTypedTerm(o, o.getType()))); CQIE rule = datalogFactory.getCQIE(head, Collections.emptyList()); termFactory.getConstantLiteral(s.getIRI().getIRIString())), propertyIRI, termFactory.getTypedTerm(termFactory.getConstantLiteral(o.getValue()), lang.getFullString()))) .orElseGet(() -> atomFactory.getMutableTripleHeadAtom(termFactory.getUriTemplate( termFactory.getConstantLiteral(s.getIRI().getIRIString())), propertyIRI, termFactory.getTypedTerm(o, o.getType()))); } else {