public static RDFDatatype getType(String s) { if ( s == null ) return null ; return TypeMapper.getInstance().getSafeTypeByName(s) ; }
private void setWithNewDatatypeForValueClass( Object value ) { Class<?> c = value.getClass(); log.warn( "inventing a datatype for " + c ); RDFDatatype dt = new AdhocDatatype( c ); TypeMapper.getInstance().registerDatatype( dt ); this.lang = ""; this.dtype = dt; this.value = value; this.lexicalForm = value.toString(); }
private void setWithNewDatatypeForValueClass( Object value ) { Class<?> c = value.getClass(); log.warn( "inventing a datatype for " + c ); RDFDatatype dt = new AdhocDatatype( c ); TypeMapper.getInstance().registerDatatype( dt ); this.lang = ""; this.dtype = dt; this.value = value; this.lexicalForm = value.toString(); }
/** Create a literal Node, when the datatype, if given, is a string */ public static Node createLiteralNode(String lex, String lang, String datatypeURI) { if ( datatypeURI != null && datatypeURI.equals("") ) datatypeURI = null ; if ( lang != null && lang.equals("") ) lang = null ; RDFDatatype dType = null ; if ( datatypeURI != null ) dType = TypeMapper.getInstance().getSafeTypeByName(datatypeURI) ; Node n = NodeFactory.createLiteral(lex, lang, dType) ; return n ; }
protected Node createLiteral(String lexicalForm, String langTag, String datatypeURI) { Node n = null ; // Can't have type and lang tag in parsing. if ( datatypeURI != null ) { RDFDatatype dType = TypeMapper.getInstance().getSafeTypeByName(datatypeURI) ; n = NodeFactory.createLiteral(lexicalForm, dType) ; } else if ( langTag != null && !langTag.isEmpty() ) n = NodeFactory.createLiteral(lexicalForm, langTag) ; else n = NodeFactory.createLiteral(lexicalForm) ; return n ; }
public void testRDFLangString_1() { // Registration RDFDatatype dt = TypeMapper.getInstance().getTypeByName(RDF.langString.getURI()) ; assertEquals(RDF.dtLangString, dt) ; assertTrue(RDF.dtLangString == dt) ; }
private static Node convert(ALiteral lit) { String dtURI = lit.getDatatypeURI(); if (dtURI == null) return NodeFactory.createLiteral(lit.toString(), lit.getLang()); if (lit.isWellFormedXML()) { return NodeFactory.createLiteral(lit.toString(), null, true); } RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(dtURI); return NodeFactory.createLiteral(lit.toString(), dt); }
private static Node convert(ALiteral lit) { String dtURI = lit.getDatatypeURI(); if (dtURI == null) return NodeFactory.createLiteral(lit.toString(), lit.getLang()); if (lit.isWellFormedXML()) { return NodeFactory.createLiteral(lit.toString(), null, true); } RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(dtURI); return NodeFactory.createLiteral(lit.toString(), dt); }
public void testDataMatches() { TypeMapper tm = TypeMapper.getInstance(); RDFDatatype dt1 = tm.getTypeByValue( new Integer( 10 ) ); RDFDatatype dt2 = tm.getTypeByValue( new Short( (short) 10 ) ); Node a = NodeFactory.createLiteral( "10", dt1 ); Node b = NodeFactory.createLiteral( "10", dt2 ); assertDiffer( "types must make a difference", a, b ); assertTrue( "A and B must express the same value", a.sameValueAs( b ) ); assertTrue( "matching literals must respect sameValueAs", a.matches( b ) ); }
public void testDataMatches() { TypeMapper tm = TypeMapper.getInstance(); RDFDatatype dt1 = tm.getTypeByValue( new Integer( 10 ) ); RDFDatatype dt2 = tm.getTypeByValue( new Short( (short) 10 ) ); Node a = NodeFactory.createLiteral( "10", dt1 ); Node b = NodeFactory.createLiteral( "10", dt2 ); assertDiffer( "types must make a difference", a, b ); assertTrue( "A and B must express the same value", a.sameValueAs( b ) ); assertTrue( "matching literals must respect sameValueAs", a.matches( b ) ); }
@Test public void test_param_string_boolean_3() { // Test invalid boolean injection String cmdText = "SELECT * WHERE { ?s ?p ?o }"; ParameterizedSparqlString query = new ParameterizedSparqlString(cmdText); query.setLiteral("o", "xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.xboolean.toString())); // We expect #boolean as booleans with invalid lexical values should not // be formatted as plain literals test(query, new String[] { "xyz", XSD.xboolean.toString() }, new String[] { "?o" }); }
@Test public void test_param_string_int_6() { // Test invalid integer injection String cmdText = "SELECT * WHERE { ?s ?p ? }"; ParameterizedSparqlString query = new ParameterizedSparqlString(cmdText); query.setLiteral(0, "xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.integer.toString())); // We do expect #integer as invalid integers should be formatted with // their type test(query, new String[] { "xyz", XSD.integer.toString() }, new String[] { "? " }); testAsQuery(query); }
@Test public void test_param_string_date_2() { // Test invalid date injection String cmdText = "SELECT * WHERE { ?s ?p ?o }"; ParameterizedSparqlString query = new ParameterizedSparqlString(cmdText); query.setLiteral("o", "xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.dateTime.toString())); // We expect #dateTime as dateTime should be formatted as typed literals test(query, new String[] { "xyz", XSD.dateTime.toString() }, new String[] { "?o" }); testAsQuery(query); }
@Test public void test_param_string_date_4() { // Test invalid date injection String cmdText = "SELECT * WHERE { ?s ?p ? }"; ParameterizedSparqlString query = new ParameterizedSparqlString(cmdText); query.setLiteral(0, "xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.dateTime.toString())); // We expect #dateTime as dateTime should be formatted as typed literals test(query, new String[] { "xyz", XSD.dateTime.toString() }, new String[] { "? " }); testAsQuery(query); }
@Test public void test_param_string_double_3() { // Test invalid double injection String cmdText = "SELECT * WHERE { ?s ?p ?o }"; ParameterizedSparqlString query = new ParameterizedSparqlString(cmdText); query.setLiteral("o", "xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.xdouble.toString())); // We expect #double as invalid doubles cannot be formatted as plain // literals test(query, new String[] { "xyz", XSD.xdouble.toString() }, new String[] { "?o" }); testAsQuery(query); }
@Test public void test_param_string_double_6() { // Test invalid double injection String cmdText = "SELECT * WHERE { ?s ?p ? }"; ParameterizedSparqlString query = new ParameterizedSparqlString(cmdText); query.setLiteral(0, "xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.xdouble.toString())); // We expect #double as invalid doubles cannot be formatted as plain // literals test(query, new String[] { "xyz", XSD.xdouble.toString() }, new String[] { "? " }); testAsQuery(query); }
public void testLiteralToString() { TypeMapper tm = TypeMapper.getInstance(); RDFDatatype dtInt = tm.getTypeByValue( new Integer( 10 ) ); Node plain = NodeFactory.createLiteral( "rhubarb", ""); Node english = NodeFactory.createLiteral( "eccentric", "en_UK"); Node typed = NodeFactory.createLiteral( "10", dtInt ); assertEquals( "\"rhubarb\"", plain.toString() ); assertEquals( "rhubarb", plain.toString( false ) ); assertEquals( "\"eccentric\"@en_UK", english.toString() ); assertEquals( "10^^http://www.w3.org/2001/XMLSchema#int", typed.toString( false ) ); }
public void testLiteralToString() { TypeMapper tm = TypeMapper.getInstance(); RDFDatatype dtInt = tm.getTypeByValue( new Integer( 10 ) ); Node plain = NodeFactory.createLiteral( "rhubarb", ""); Node english = NodeFactory.createLiteral( "eccentric", "en_UK"); Node typed = NodeFactory.createLiteral( "10", dtInt ); assertEquals( "\"rhubarb\"", plain.toString() ); assertEquals( "rhubarb", plain.toString( false ) ); assertEquals( "\"eccentric\"@en_UK", english.toString() ); assertEquals( "10^^http://www.w3.org/2001/XMLSchema#int", typed.toString( false ) ); }
@Test public void test_param_string_append_integer_2() { // Test appending text ParameterizedSparqlString query = new ParameterizedSparqlString(); query.append("SELECT *"); query.append('\n'); query.append("WHERE { ?s ?p "); query.appendLiteral("xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.integer.toString())); query.append("}"); test(query, new String[] { "SELECT", "*", "\n", "WHERE", "?s", "?p", "xyz", XSD.integer.toString() }, new String[] {}); testAsQuery(query); }
@Test public void test_param_string_append_boolean_2() { // Test appending text ParameterizedSparqlString query = new ParameterizedSparqlString(); query.append("SELECT *"); query.append('\n'); query.append("WHERE { ?s ?p "); query.appendLiteral("xyz", TypeMapper.getInstance().getSafeTypeByName(XSD.xboolean.toString())); query.append("}"); test(query, new String[] { "SELECT", "*", "\n", "WHERE", "?s", "?p", "xyz", XSD.xboolean.toString() }, new String[] {}); testAsQuery(query); }