@Override public void addValue(String subject, String predicate, String value, String dataType, String graph) throws RdfProcessingFailedException { try { if (Objects.equals(subject, baseUri) && isDescriptionPredicate(predicate)) { ValueFactory vf = SimpleValueFactory.getInstance(); model.add(vf.createIRI(subject), vf.createIRI(predicate), vf.createLiteral(value)); } } catch (Exception e) { throw new RdfProcessingFailedException(e); } }
private void flushPendingStatement() throws RDFHandlerException { if (predicate != null) { Resource res = valueFactory.createBNode(); handler.handleStatement(valueFactory.createStatement(subject, predicate, res)); subject = res; } }
private Resource getResource(String s, ValueFactory vf) { // taken from org.eclipse.rdf4j.model.impl.SimpleIRI // explicit storage of blank nodes in the graph to be considered if(s.indexOf(58) >= 0){ return vf.createIRI(s); } else{ return vf.createBNode(s); } }
private void addQueryNode(Model m, Resource implNode, IRI predicate, String queryText) { if (null != queryText) { ValueFactory factory = SimpleValueFactory.getInstance(); BNode queryNode = factory.createBNode(); m.add(implNode, predicate, queryNode); m.add(queryNode, RDF.TYPE, SP.CONSTRUCT_CLASS); m.add(queryNode, SP.TEXT_PROPERTY, factory.createLiteral(queryText)); } } }
public Literal evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException { if (args.length != 1) { throw new ValueExprEvaluationException("UCASE requires exactly 1 argument, got " + args.length); } if (args[0] instanceof Literal) { Literal literal = (Literal)args[0]; // UpperCase function accepts only string literal if (QueryEvaluationUtil.isStringLiteral(literal)) { String lexicalValue = literal.getLabel().toUpperCase(); Optional<String> language = literal.getLanguage(); if (language.isPresent()) { return valueFactory.createLiteral(lexicalValue, language.get()); } else if (XMLSchema.STRING.equals(literal.getDatatype())) { return valueFactory.createLiteral(lexicalValue, XMLSchema.STRING); } else { return valueFactory.createLiteral(lexicalValue); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } }
protected Literal convert(ValueFactory valueFactory, Value value) throws ValueExprEvaluationException { if (value instanceof Literal) { Literal literal = (Literal)value; IRI datatype = literal.getDatatype(); if (XMLDatatypeUtil.isNumericDatatype(datatype)) { // FIXME: doubles must be processed separately, see // http://www.w3.org/TR/xpath-functions/#casting-from-primitive-to-primitive try { double doubleValue = literal.doubleValue(); return valueFactory.createLiteral(doubleValue); } catch (NumberFormatException e) { throw new ValueExprEvaluationException(e.getMessage(), e); } } else if (datatype.equals(XMLSchema.BOOLEAN)) { try { return valueFactory.createLiteral(literal.booleanValue() ? 1.0 : 0.0); } catch (IllegalArgumentException e) { throw typeError(literal, e); } } } throw typeError(value, null); }
protected Literal convert(ValueFactory valueFactory, Value value) throws ValueExprEvaluationException { if (value instanceof Literal) { Literal literal = (Literal)value; IRI datatype = literal.getDatatype(); if (XMLDatatypeUtil.isNumericDatatype(datatype)) { // FIXME: floats and doubles must be processed separately, see // http://www.w3.org/TR/xpath-functions/#casting-from-primitive-to-primitive try { BigDecimal decimalValue = literal.decimalValue(); return valueFactory.createLiteral(decimalValue.toPlainString(), XMLSchema.DECIMAL); } catch (NumberFormatException e) { throw typeError(literal, e); } } else if (datatype.equals(XMLSchema.BOOLEAN)) { try { return valueFactory.createLiteral(literal.booleanValue() ? "1.0" : "0.0", XMLSchema.DECIMAL); } catch (IllegalArgumentException e) { throw typeError(literal, e); } } } throw typeError(value, null); }
/** * Creates a {@link Literal}. * @param i int representation of the {@link org.eclipse.rdf4j.model.Literal} * @return valid {@link org.eclipse.rdf4j.model.Literal} */ public static Literal literal(int i) { return valueFactory.createLiteral(i); }
private void reportStatement(Resource subject, IRI predicate, Value object) throws RDFHandlerException { rdfHandler.handleStatement(vf.createStatement(subject, predicate, object)); }
protected Literal convert(ValueFactory valueFactory, Value value) throws ValueExprEvaluationException { if (value instanceof Literal) { Literal literal = (Literal)value; IRI datatype = literal.getDatatype(); if (XMLDatatypeUtil.isNumericDatatype(datatype)) { // FIXME: doubles must be processed separately, see // http://www.w3.org/TR/xpath-functions/#casting-from-primitive-to-primitive try { float floatValue = literal.floatValue(); return valueFactory.createLiteral(floatValue); } catch (NumberFormatException e) { throw typeError(literal, e); } } else if (datatype.equals(XMLSchema.BOOLEAN)) { try { return valueFactory.createLiteral(literal.booleanValue() ? 1f : 0f); } catch (IllegalArgumentException e) { throw typeError(literal, e); } } } throw typeError(value, null); }
/** * Creates a copy tool parent time offset {@link RyaStatement} from the specified offset. * @param timeOffset the copy tool parent time offset. (in milliseconds). * @return the {@link RyaStatement} for the copy tool parent time offset. */ public static RyaStatement createTimeOffsetRyaStatement(final long timeOffset) { final Literal literal = VALUE_FACTORY.createLiteral(timeOffset); final RyaType timeObject = new RyaType(literal.getDatatype(), literal.stringValue()); return new RyaStatement(RTS_SUBJECT_RYA, RTS_TIME_OFFSET_PREDICATE_RYA, timeObject); }
@Override public Resource export(Model m) { Resource implNode = super.export(m); ValueFactory vf = SimpleValueFactory.getInstance(); m.setNamespace("sl", LuceneSailConfigSchema.NAMESPACE); if (indexDir != null) { m.add(implNode, INDEX_DIR, SimpleValueFactory.getInstance().createLiteral(indexDir)); } for (String key : getParameterNames()) { m.add(implNode, vf.createIRI(LuceneSailConfigSchema.NAMESPACE, key), vf.createLiteral(getParameter(key))); } return implNode; }
private Set<Statement> reifyQualifier(KnowledgeBase kb, KBQualifier aQualifier) { Resource statementId = vf.createBNode(aQualifier.getKbStatement().getStatementId()); KBHandle qualifierProperty = aQualifier.getKbProperty(); IRI qualifierPredicate = vf.createIRI(qualifierProperty.getIdentifier()); Value qualifierValue = valueMapper.mapQualifierValue(aQualifier, vf); Statement qualifierStatement = vf .createStatement(statementId, qualifierPredicate, qualifierValue); Set<Statement> originalStatements = new HashSet<>(); originalStatements.add(qualifierStatement); //id P V return originalStatements; }
@Override public Resource export(Model m) { Resource implNode = super.export(m); m.setNamespace("sparql", NAMESPACE); if (getQueryEndpointUrl() != null) { m.add(implNode, QUERY_ENDPOINT, vf.createIRI(getQueryEndpointUrl())); } if (getUpdateEndpointUrl() != null) { m.add(implNode, UPDATE_ENDPOINT, vf.createIRI(getUpdateEndpointUrl())); } return implNode; }
/** * Creates a {@link org.eclipse.rdf4j.model.IRI}. * @param namespace a base namespace for the {@link org.eclipse.rdf4j.model.IRI} * @param localName a local name to associate with the namespace * @return a valid {@link org.eclipse.rdf4j.model.IRI} */ public static org.eclipse.rdf4j.model.IRI iri(String namespace, String localName) { return valueFactory.createIRI(namespace, localName); }
@Override protected Value evaluate(ValueFactory valueFactory, Value arg1, Value arg2) throws ValueExprEvaluationException { if (!(arg1 instanceof Literal)) { throw new ValueExprEvaluationException("First argument must be a literal"); } if (!(arg2 instanceof IRI)) { throw new ValueExprEvaluationException("Second argument must be a datatype"); } Literal value = (Literal)arg1; IRI targetDatatype = (IRI)arg2; Function func = FunctionRegistry.getInstance().get(targetDatatype.stringValue()).orElse(null); return (func != null) ? func.evaluate(valueFactory, value) : valueFactory.createLiteral(value.getLabel(), targetDatatype); } }
@Override public void delValue(String subject, String predicate, String value, String dataType, String graph) throws RdfProcessingFailedException { try { if (Objects.equals(subject, baseUri)) { ValueFactory vf = SimpleValueFactory.getInstance(); model.remove(vf.createIRI(subject), vf.createIRI(predicate), vf.createLiteral(value)); } } catch (Exception e) { throw new RdfProcessingFailedException(e); } }
public Value evaluate(Lang node, BindingSet bindings) throws ValueExprEvaluationException, QueryEvaluationException { Value argValue = evaluate(node.getArg(), bindings); if (argValue instanceof Literal) { Literal literal = (Literal)argValue; return tripleSource.getValueFactory().createLiteral(literal.getLanguage().orElse("")); } throw new ValueExprEvaluationException(); }
@Override protected Value evaluate(ValueFactory valueFactory, Value arg1, Value arg2) throws ValueExprEvaluationException { if (!(arg1 instanceof Literal) || !(arg2 instanceof Literal)) { throw new ValueExprEvaluationException("Both arguments must be literals"); } Literal date = (Literal)arg1; Literal format = (Literal)arg2; SimpleDateFormat formatter = new SimpleDateFormat(format.getLabel()); String value = formatter.format(date.calendarValue().toGregorianCalendar().getTime()); return valueFactory.createLiteral(value); } }
@Test public void periodicNodeNotPresentTest() throws Exception { List<ValueExpr> values = Arrays.asList(new Var("time"), new ValueConstant(VF.createLiteral(12.0)), new ValueConstant(VF.createLiteral(6.0)), new ValueConstant(VF.createIRI(PeriodicQueryUtil.temporalNameSpace + "hours"))); FunctionCall func = new FunctionCall("uri:func", values); Optional<PeriodicQueryNode> node1 = PeriodicQueryUtil.getPeriodicQueryNode(func, new Join()); Assert.assertEquals(false, node1.isPresent()); }