default RDFDatatype getXsdDatetimeDatatype() { return getDatatype(XSD.DATETIME); } }
default RDFDatatype getXsdDecimalDatatype() { return getDatatype(XSD.DECIMAL); }
default RDFDatatype getXsdFloatDatatype() { return getDatatype(XSD.FLOAT); }
default RDFDatatype getXsdIntegerDatatype() { return getDatatype(XSD.INTEGER); }
default RDFDatatype getXsdBooleanDatatype() { return getDatatype(XSD.BOOLEAN); }
default RDFDatatype getXsdDoubleDatatype() { return getDatatype(XSD.DOUBLE); }
default RDFDatatype getXsdStringDatatype() { return getDatatype(XSD.STRING); }
@Override public ValueConstant getConstantLiteral(String value, IRI type) { return getConstantLiteral(value, typeFactory.getDatatype(type)); }
@Override public ImmutableFunctionalTerm getImmutableTypedTerm(ImmutableTerm value, IRI datatypeIRI) { return getImmutableTypedTerm(value, typeFactory.getDatatype(datatypeIRI)); }
@Override public Function getTypedTerm(Term value, IRI datatypeIRI) { return getTypedTerm(value, typeFactory.getDatatype(datatypeIRI)); }
private void process(String value, IRI datatype) { result = termFactory.getConstantLiteral(value, typeFactory.getDatatype(datatype)); }
@Override public DatatypePredicate getRequiredTypePredicate(IRI datatypeIri) { if (datatypeIri.equals(LANGSTRING)) throw new IllegalArgumentException("Lang string predicates are not unique (they depend on the language tag)"); return getRequiredTypePredicate(typeFactory.getDatatype(datatypeIri)); }
public SemanticIndexViewsManager(TypeFactory typeFactory) { this.typeFactory = typeFactory; init(); // special case of COL_TYPE.OBJECT and COL_TYPE.BNODE (both are mapped to 1) colTypetoSITable = new HashMap<>(); colTypetoSITable.put(typeFactory.getBlankNodeType(), 1); colTypetoSITable.put(typeFactory.getIRITermType(), 1); // Class SITable has value 0 (skip it) for (int i = 2; i < SITableToIRI.length; i++) colTypetoSITable.put(typeFactory.getDatatype(SITableToIRI[i]), i); }
@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 boolean isNumeric(ValueConstant constant) { String constantValue = constant.getValue(); Optional<COL_TYPE> type = TYPE_FACTORY.getDatatype(constantValue); if (type.isPresent()) { Predicate p = TYPE_FACTORY.getTypePredicate(type.get()); return isNumeric(p); } return false; }
@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); }
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 boolean isNumeric(ValueConstant constant) { String constantValue = constant.getValue(); RDFDatatype type = typeFactory.getDatatype(rdfFactory.createIRI(constantValue)); return type.isA(OntopInternal.NUMERIC); }
private ValueConstant getValueOfLiteral(OWLLiteral object) { if (!object.getLang().isEmpty()) { return termFactory.getConstantLiteral(object.getLiteral(), object.getLang()); } else { RDFDatatype type = typeFactory.getDatatype(rdfFactory.createIRI(object.getDatatype().getIRI().toString())); return termFactory.getConstantLiteral(object.getLiteral(), type); } }