default RDFDatatype getXsdDatetimeDatatype() { return getDatatype(XSD.DATETIME); } }
this.typeFactory = typeFactory; ImmutableMap.Builder<Integer, TermType> sqlToTermBuilder = ImmutableMap.builder(); sqlToTermBuilder.put(Types.VARCHAR, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.CHAR, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.LONGNVARCHAR, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.LONGVARCHAR, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.NVARCHAR, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.NCHAR, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.INTEGER, typeFactory.getXsdIntegerDatatype()); sqlToTermBuilder.put(Types.BIGINT, typeFactory.getXsdIntegerDatatype()); sqlToTermBuilder.put(Types.SMALLINT, typeFactory.getXsdIntegerDatatype()); sqlToTermBuilder.put(Types.TINYINT, typeFactory.getXsdIntegerDatatype()); sqlToTermBuilder.put(Types.NUMERIC, typeFactory.getXsdDecimalDatatype()); sqlToTermBuilder.put(Types.DECIMAL, typeFactory.getXsdDecimalDatatype()); sqlToTermBuilder.put(Types.FLOAT, typeFactory.getXsdDoubleDatatype()); // conversion to float to follow r2rml Natural Mapping of SQL Values sqlToTermBuilder.put(Types.DOUBLE, typeFactory.getXsdDoubleDatatype()); sqlToTermBuilder.put(Types.REAL, typeFactory.getXsdDoubleDatatype()); sqlToTermBuilder.put(Types.DATE, typeFactory.getDatatype(XSD.DATE)); sqlToTermBuilder.put(Types.TIME, typeFactory.getDatatype(XSD.TIME)); sqlToTermBuilder.put(Types.TIMESTAMP, typeFactory.getDatatype(XSD.DATETIME)); //GX: needs check sqlToTermBuilder.put(Types.TIMESTAMP_WITH_TIMEZONE, typeFactory.getDatatype(XSD.DATETIME)); //BC: needs check sqlToTermBuilder.put(Types.BOOLEAN, typeFactory.getXsdBooleanDatatype()); sqlToTermBuilder.put(Types.BIT, typeFactory.getXsdBooleanDatatype()); sqlToTermBuilder.put(Types.CLOB, typeFactory.getXsdStringDatatype()); sqlToTermBuilder.put(Types.OTHER, typeFactory.getXsdStringDatatype()); sqlToTermTypeMap = sqlToTermBuilder.build(); datatypeBuilder.put(typeFactory.getXsdBooleanDatatype(), Types.BOOLEAN);
/** * Do not use this construction if you know the language tag! */ public PredefinedTermTypeInferenceRule(Predicate.COL_TYPE predefinedColType) { this(TYPE_FACTORY.getTermType(predefinedColType)); }
public NonIntegerNumericInferenceRule(TypeFactory typeFactory) { integerDatatype = typeFactory.getXsdIntegerDatatype(); decimalDatatype = typeFactory.getXsdDecimalDatatype(); }
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); }
@Inject private AtomFactoryImpl(TermFactory termFactory, TypeFactory typeFactory, org.apache.commons.rdf.api.RDF rdfFactory) { this.termFactory = termFactory; this.typeFactory = typeFactory; triplePredicate = new TriplePredicateImpl(ImmutableList.of( typeFactory.getAbstractObjectRDFType(), typeFactory.getIRITermType(), typeFactory.getAbstractRDFTermType()), rdfFactory); quadPredicate = new QuadPredicateImpl(ImmutableList.of( typeFactory.getAbstractObjectRDFType(), typeFactory.getIRITermType(), typeFactory.getAbstractRDFTermType(), typeFactory.getIRITermType()), rdfFactory); }
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); } }
private DummyTypeMapper(TypeFactory typeFactory) { this.defaultType = typeFactory.getXsdStringDatatype(); }
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 void visit(SWRLLiteralArgument node) { OWLLiteral literal=node.getLiteral(); if (literal.isBoolean()) terms.add(termFactory.getBooleanConstant(literal.parseBoolean())); else if(literal.hasLang()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), literal.getLang())); else if (literal.isDouble()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), typeFactory.getXsdDoubleDatatype())); else if (literal.isFloat()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), typeFactory.getXsdDecimalDatatype())); else if (literal.isInteger()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), typeFactory.getXsdIntegerDatatype())); else termFactory.getConstantLiteral(literal.getLiteral()); }
@Inject private TermFactoryImpl(TypeFactory typeFactory, OntopModelSettings settings) { // protected constructor prevents instantiation from other classes. this.typeFactory = typeFactory; RDFDatatype xsdBoolean = typeFactory.getXsdBooleanDatatype(); this.valueTrue = new ValueConstantImpl("true", xsdBoolean); this.valueFalse = new ValueConstantImpl("false", xsdBoolean); this.valueNull = new ValueConstantImpl("null", typeFactory.getXsdStringDatatype()); this.provenanceConstant = new ValueConstantImpl("ontop-provenance-constant", typeFactory.getXsdStringDatatype()); this.immutabilityTools = new ImmutabilityTools(this); this.type2FunctionSymbolMap = new HashMap<>(); this.isTestModeEnabled = settings.isTestModeEnabled(); this.templateCounter = new AtomicInteger(); this.templateSuffix = new ConcurrentHashMap<>(); }
private void addMinimalEqualityToLeftOrNestedInnerJoin(Function algebraFunctionalTerm) { int booleanAtoms = 0; for (Term term : algebraFunctionalTerm.getTerms()) { Function f = (Function) term; if (f.isAlgebraFunction()) { addMinimalEqualityToLeftOrNestedInnerJoin(f); } if (f.isOperation()) booleanAtoms++; } if (algebraFunctionalTerm.isAlgebraFunction() && booleanAtoms == 0) { Function trivialEquality = termFactory.getFunctionEQ( termFactory.getConstantLiteral("1", typeFactory.getXsdIntegerDatatype()), termFactory.getConstantLiteral("1", typeFactory.getXsdIntegerDatatype())); algebraFunctionalTerm.getTerms().add(trivialEquality); } }
if ((functionSymbol instanceof BNodePredicate) || (functionSymbol instanceof URITemplatePredicate)) { return Optional.of(TYPE_FACTORY.getTermType(OBJECT)); COL_TYPE internalDatatype = TYPE_FACTORY.getInternalType(datatypeConstructionFunctionSymbol) .orElseThrow(() -> new RuntimeException("Unsupported datatype: " + functionSymbol + "\n TODO: throw a better exception")); ? Optional.of(TYPE_FACTORY.getTermType(generateFreshVariable())) : Optional.of(TYPE_FACTORY.getTermType(internalDatatype));
protected URITemplatePredicateImpl(int arity, String suffix, TypeFactory typeFactory) { super(URI_PREFIX + arity + suffix, IntStream.range(0, arity) .boxed() // TODO: require strings .map(i -> typeFactory.getAbstractAtomicTermType()) .collect(ImmutableCollectors.toList())); type = typeFactory.getIRITermType(); }
protected IRIConstantImpl(IRI iri, TypeFactory typeFactory) { this.iri = iri; this.identifier = iri.hashCode(); this.type = typeFactory.getIRITermType(); }
IRI datatype = l.getDatatype(); RDFDatatype type = (datatype == null) ? typeFactory.getXsdStringDatatype() : typeFactory.getDatatype(rdfFactory.createIRI(datatype.stringValue())); c2 = termFactory.getConstantLiteral(l.getLabel(), type);
private final void init() { ImmutableList<ObjectRDFType> objectTypes = ImmutableList.of(typeFactory.getIRITermType(), typeFactory.getBlankNodeType()); IRI[] datatypeIRIs = { XSD.BOOLEAN, XSD.DATETIME, XSD.DATETIMESTAMP, XSD.DECIMAL, XSD.DOUBLE, XSD.INTEGER, XSD.INT, XSD.UNSIGNED_INT, XSD.NEGATIVE_INTEGER, XSD.NON_NEGATIVE_INTEGER, XSD.POSITIVE_INTEGER, XSD.NON_POSITIVE_INTEGER, XSD.FLOAT, XSD.LONG, XSD.STRING }; for (ObjectRDFType type1 : objectTypes) { String value = type1.isBlankNode() ? "TRUE" : "FALSE"; String filter = "ISBNODE = " + value + " AND "; { String select = RDBMSSIRepositoryManager.classTable.getSELECT(filter); String insert = RDBMSSIRepositoryManager.classTable.getINSERT("?, ?, " + value); SemanticIndexViewID viewId = new SemanticIndexViewID(type1); SemanticIndexView view = new SemanticIndexView(viewId, select, insert); views.put(view.getId(), view); classViews.add(view); } for (ObjectRDFType type2 : objectTypes) { initObjectProperty(type1, type2); } for (IRI iriType2 : datatypeIRIs) { initDataProperty(type1, typeFactory.getDatatype(iriType2)); } } }
@Override public TermType getTermType(int sqlType, String typeName) { return Optional.ofNullable(sqlToTermTypeMap.get(sqlType)) // TODO: use another default type .orElse(typeFactory.getXsdStringDatatype()); }
typeFactory.getXsdIntegerDatatype()));
if ((functionSymbol instanceof BNodePredicate) || (functionSymbol instanceof URITemplatePredicate)) { return Optional.of(typeFactory.getIRITermType());