com.hp.hpl.jena.datatypes.RDFDatatype Java Examples

public static NodeType typedLiteral(RDFDatatype datatype) {
	// TODO These subclasses can be abolished; just introduce an RDFDatatypeValidator instead
	if (datatype.equals(XSDDatatype.XSDdate)) {
		return XSD_DATE;
	}
	if (datatype.equals(XSDDatatype.XSDtime)) {
		return XSD_TIME;
	}
	if (datatype.equals(XSDDatatype.XSDdateTime)) {
		return XSD_DATETIME;
	}
	if (datatype.equals(XSDDatatype.XSDboolean)) {
		return XSD_BOOLEAN;
	}
	return new LiteralNodeType("", datatype);
}
 

@Override
public LiteralLabel getLiteral() {
 graphDb.beginTx();
 String value = delegate.getProperty(NeoGraph.PROPERTY_VALUE).toString();
 String language = null;
 RDFDatatype datatype = null;

 if(delegate.hasProperty(NeoGraph.PROPERTY_LANGUAGE))
	language = delegate.getProperty(NeoGraph.PROPERTY_LANGUAGE).toString();

 TypeMapper mapper = new TypeMapper();
 if(delegate.hasProperty(NeoGraph.PROPERTY_DATATYPE))
	 datatype = mapper.getTypeByName( delegate.getProperty(NeoGraph.PROPERTY_DATATYPE).toString());

 LiteralLabel label = LiteralLabelFactory.create(value, language, datatype); //datatype);
 //System.out.println("Label: " +label);
 return label;
}
 

public NodeType getNodeType() {
	if (map.getDatatype() != null) {
		RDFDatatype datatype = TypeMapper.getInstance().getSafeTypeByName(map.getDatatype());
		return TypedNodeMaker.typedLiteral(datatype);
	}
	if (map.getLang() != null) {
		return TypedNodeMaker.languageLiteral(map.getLang());
	}
	if (super.getNodeType() != null) {
		return super.getNodeType();
	}
	return TypedNodeMaker.PLAIN_LITERAL;
}
 

@Override
public RDFDatatype getLiteralDatatype(){
 graphDb.beginTx();
 RDFDatatype datatype = null;
 TypeMapper mapper = new TypeMapper();
 if(delegate.hasProperty(NeoGraph.PROPERTY_DATATYPE))
	 datatype = mapper.getTypeByName( delegate.getProperty(NeoGraph.PROPERTY_DATATYPE).toString());
return datatype;
}
 

@Override
public void performAdd(final Triple triple) {
	updateCommand.clear();
	
	final SolrInputDocument document = new SolrInputDocument();
	this.updateCommand.solrDoc = document;
	document.setField(Field.C, graphNodeStringified);
	document.setField(Field.S, asNt(triple.getSubject()));
	document.setField(Field.P, asNtURI(triple.getPredicate()));
	document.setField(Field.ID, UUID.nameUUIDFromBytes(
			new StringBuilder()
				.append(graphNodeStringified)
				.append(triple.getSubject())
				.append(triple.getPredicate())
				.append(triple.getObject())
				.toString().getBytes()).toString());
	
	final String o = asNt(triple.getObject());
	document.setField(Field.O, o);

	final Node object = triple.getObject();
	if (object.isLiteral()) {
		final String language = object.getLiteralLanguage();
		document.setField(Field.LANG, isNotNullOrEmptyString(language) ? language : NULL_LANGUAGE);				

		final RDFDatatype dataType = object.getLiteralDatatype();
		final Object value = object.getLiteralValue();
		registry.get(dataType != null ? dataType.getURI() : null).inject(document, value);
	} else {
		registry.catchAllFieldInjector.inject(document, o);
	}			

	try {
		updateProcessor.processAdd(updateCommand);
	} catch (final Exception exception) {
		LOGGER.error(MessageCatalog._00113_NWS_FAILURE, exception);
		throw new AddDeniedException(exception.getMessage(), triple);
	}
}
 

@Override
public void performAdd(final Triple triple) {
	final SolrInputDocument document = new SolrInputDocument();
	document.setField(Field.C, graphNodeStringified);
	document.setField(Field.S, asNt(triple.getSubject()));
	document.setField(Field.P, asNtURI(triple.getPredicate()));
	document.setField(Field.ID, UUID.nameUUIDFromBytes(
			new StringBuilder()
				.append(graphNodeStringified)
				.append(triple.getSubject())
				.append(triple.getPredicate())
				.append(triple.getObject())
				.toString().getBytes()).toString());
	
	final Node object = triple.getObject();
	final String o = asNt(object);
	document.setField(Field.O, o);

	if (object.isLiteral()) {
		final String language = object.getLiteralLanguage();
		document.setField(Field.LANG, isNotNullOrEmptyString(language) ? language : NULL_LANGUAGE);				

		final RDFDatatype dataType = object.getLiteralDatatype();
		final Object value = object.getLiteralValue();
		registry.get(dataType != null ? dataType.getURI() : null).inject(document, value);
	} else {
		registry.catchAllFieldInjector.inject(document, o);
	}			

	try {
		cloud.add(document);
	} catch (final Exception exception) {
		LOGGER.error(MessageCatalog._00113_NWS_FAILURE, exception);
		throw new AddDeniedException(exception.getMessage(), triple);
	}
}
 

/**
 * Builds a DELETE query.
 * 
 * @param triple the triple (maybe a pattern?) that must be deleted.
 * @return a DELETE query.
 */
String deleteQuery(final Triple triple) {
	final StringBuilder builder = new StringBuilder();
	if (triple.getSubject().isConcrete()) {
		and(builder).append(fq(Field.S, asNt(triple.getSubject()))); 
	}
	
	if (triple.getPredicate().isConcrete()) {
		and(builder).append(fq(Field.P, asNtURI(triple.getPredicate())));
	}
		
	if (triple.getObject().isConcrete()) {
		and(builder);
		
		final Node o = triple.getObject();
		if (o.isLiteral()) {
			final String language = o.getLiteralLanguage();
			if (Strings.isNotNullOrEmptyString(language)) {
				builder
					.append(fq(Field.LANG, language))
					.append(" AND ");
			}
			
			final String literalValue = o.getLiteralLexicalForm(); 
			final RDFDatatype dataType = o.getLiteralDatatype();
			registry.get(dataType != null ? dataType.getURI() : null).addConstraint(builder, literalValue);
		} else {
			registry.catchAllInjector().addConstraint(builder, asNt(o));
		}
	}
	
	return and(builder).append(fq(Field.C, graphNodeStringified)).toString();
}
 

LiteralNodeType(String language, RDFDatatype datatype) {
	this.language = language;
	this.datatype = datatype;
}
 

public static String toString(RDFDatatype datatype) {
	return qNameOrURI(datatype.getURI(), PrefixMapping.Standard);
}
 

@Test
public void testOldDataTypesUsedAsIntended() throws Exception {
	
	// laut der jena-dev Mailingliste, sollte man Datentypen so erzeugen:
	// siehe http://groups.yahoo.com/group/jena-dev/message/14052
	
	// String dtURI = tmpProp.getRange().getURI();
	// RDFDatatype dt = TypeMapper.getInstance().getTypeByName(dtURI);
	// Literal tmpLit = tmpModel.createTypedLiteral("123", dt );
	
	// leider f�hrt das dann dazu das "test"^^xsd:funky equal zu "test" ist,
	// da dann xsd:funky ein unknown data type ist und
	// somit "test"^^xsd:funky genau wie ein plain literal behandelt wird.
	
	// die erste DatenTyp URI
	// URI testA = URIUtils.createURI("test://somedata-A");
	String strTestA = new String("test://somedata-A");
	// die zweite DatenTyp URI
	// URI testB = URIUtils.createURI("test://somedata-B");
	String strTestB = new String("test://somedata-B");
	
	// der erste BaseDatatype wird von der ersten DatenTyp URI erzeugt
	RDFDatatype DTtestA1 = TypeMapper.getInstance().getTypeByName(strTestA);
	// der zweite BaseDatatype ebenso
	RDFDatatype DTtestA2 = TypeMapper.getInstance().getTypeByName(strTestA);
	// f�r den dritten BaseDatatype nehmen wir eine neue Datentyp URI
	RDFDatatype DTtestB = TypeMapper.getInstance().getTypeByName(strTestB);
	
	com.hp.hpl.jena.rdf.model.Model model = ModelFactory.createDefaultModel();
	
	Literal litA11 = model.createTypedLiteral("teststring", DTtestA1);
	Literal litA12 = model.createTypedLiteral("teststring", DTtestA1);
	Literal litA2 = model.createTypedLiteral("teststring", DTtestA2);
	@SuppressWarnings("unused")
	Literal litB = model.createTypedLiteral("teststring", DTtestB);
	
	// alle Literals haben den gleichen Wert !
	
	// dann wollen wir mal schauen was passiert:
	
	// reflexivit�t: A == A , passt
	assertTrue(litA11.equals(litA11));
	// gleicher Inhalt, in zwei versch. Objekten, passt auch
	assertTrue(litA11.equals(litA12));
	// zwei Objekte, mit untersch. BaseDatatypes, von der gleichen Datatype
	// URI:
	
	assertTrue(litA11.equals(litA2));
	// und zur sicherheit: 2 versch Datentyp URIs:
	
	// -> das sollte eigentlich nicht sein
	// TODO jena bug assertFalse(litA11.equals(litB));
	
}
 

/**
 * Builds a DELETE query.
 * 
 * @param triple the triple (maybe a pattern?) that must be deleted.
 * @return a DELETE query.
 */
String deleteQuery(final Triple triple) {
	final StringBuilder builder = new StringBuilder();
	if (triple.getSubject().isConcrete()) {
		builder
			.append(Field.S)
			.append(":\"")
			.append(asNt(triple.getSubject()))
			.append("\"");
	}
	
	if (triple.getPredicate().isConcrete()) {
		if (builder.length() != 0) {
			builder.append(" AND ");
		}
		
		builder
			.append(Field.P)
			.append(":\"")
			.append(asNtURI(triple.getPredicate()))
			.append("\"");
	}
		
	if (triple.getObject().isConcrete()) {
		if (builder.length() != 0) {
			builder.append(" AND ");
		}
		
		final Node o = triple.getObject();
		if (o.isLiteral()) {
			final String language = o.getLiteralLanguage();
			builder
				.append(Field.LANG)
				.append(":")
				.append(isNotNullOrEmptyString(language) ? language : NULL_LANGUAGE)
				.append(" AND ");
			
			final String literalValue = o.getLiteralLexicalForm(); 
			final RDFDatatype dataType = o.getLiteralDatatype();
			registry.get(dataType != null ? dataType.getURI() : null).addConstraint(builder, literalValue);
		} else {
			registry.catchAllInjector().addConstraint(builder, asNt(o));
		}
	}
		
	
	return builder
		.append(" AND ")
		.append(Field.C)
		.append(":\"")
		.append(graphNodeStringified)
		.append("\"")
		.toString();
}
 

SolrIndexSearcher.QueryCommand queryCommand(final Triple pattern, final SortSpec sortSpec) throws SyntaxError {
    final SolrIndexSearcher.QueryCommand cmd = new SolrIndexSearcher.QueryCommand();
    cmd.setQuery(new MatchAllDocsQuery());
    cmd.setSort(sortSpec.getSort());
    cmd.setLen(queryFetchSize);
    cmd.setFlags(cmd.getFlags() | SolrIndexSearcher.GET_DOCSET);
    
    final List<Query> filters = new ArrayList<Query>();
    
	final Node s = pattern.getMatchSubject();
	final Node p = pattern.getMatchPredicate();
	final Node o = pattern.getMatchObject();
	
	if (s != null) {
		filters.add(new TermQuery(new Term(Field.S, asNt(s))));
	}
	
	if (p != null) {
		filters.add(new TermQuery(new Term(Field.P, asNtURI(p))));
	}
	
	if (o != null) {
		if (o.isLiteral()) {
			final String language = o.getLiteralLanguage();
			filters.add(
					isNotNullOrEmptyString(language) 
						? languageTermQuery(language) 
						: NULL_LANGUAGE_TERM_QUERY);
			
			final String literalValue = o.getLiteralLexicalForm(); 
			final RDFDatatype dataType = o.getLiteralDatatype();
			registry.get(
					dataType != null 
						? dataType.getURI() 
						: null).addFilterConstraint(filters, literalValue, request);
		} else {
			filters.add(new TermQuery(new Term(Field.TEXT_OBJECT, asNt(o))));		
		}
	}
	
	filters.add(graphTermQuery);				
	
	cmd.setFilterList(filters);
	return cmd;
}
 

/**
 * Limits this node set to literals having a particular language
 * tag and datatype.
 * @param language The language tag of all nodes in the set, or <tt>null</tt>
 * 		for plain or datatype literals
 * @param datatype The datatype of all nodes in the set, or <tt>null</tt>
 * 		for plain literals
 */
public void limitToLiterals(String language, RDFDatatype datatype);
 

public void limitToLiterals(String language, RDFDatatype datatype) { } 

public void limitToLiterals(String language, RDFDatatype datatype) { }