You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by rv...@apache.org on 2013/06/10 21:29:46 UTC
svn commit: r1491571 [2/2] - in
/jena/Experimental/jena-jdbc/jena-jdbc-core/src:
main/java/org/apache/jena/jdbc/results/
main/java/org/apache/jena/jdbc/results/metadata/
test/java/org/apache/jena/jdbc/results/
Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java?rev=1491571&r1=1491570&r2=1491571&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java Mon Jun 10 19:29:46 2013
@@ -36,12 +36,11 @@ import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
+import java.util.HashMap;
import org.apache.jena.jdbc.JdbcCompatibility;
-import org.apache.jena.jdbc.connections.JenaConnection;
import org.apache.jena.jdbc.results.metadata.AskResultsMetadata;
import org.apache.jena.jdbc.results.metadata.TripleResultsMetadata;
-import org.apache.jena.jdbc.statements.JenaStatement;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
@@ -61,6 +60,7 @@ import com.hp.hpl.jena.rdf.model.ModelFa
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
+import com.hp.hpl.jena.sparql.util.NodeFactoryExtra;
import com.hp.hpl.jena.vocabulary.XSD;
/**
@@ -109,7 +109,11 @@ public abstract class AbstractResultSetT
Literal objLangLiteral = m.createLiteral("simple", "en");
Literal objBoolean = m.createTypedLiteral(true);
Literal objByte = m.createTypedLiteral(Byte.toString((byte) 123), XSDDatatype.XSDbyte);
- Literal objDate = m.createTypedLiteral(Calendar.getInstance());
+ Literal objDateTime = m.createTypedLiteral(Calendar.getInstance());
+ Literal objDate = m.createTypedLiteral(NodeFactoryExtra.dateToNode(Calendar.getInstance()).getLiteralLexicalForm(),
+ XSDDatatype.XSDdate);
+ Literal objTime = m.createTypedLiteral(NodeFactoryExtra.timeToNode(Calendar.getInstance()).getLiteralLexicalForm(),
+ XSDDatatype.XSDtime);
Literal objChar = m.createTypedLiteral('a');
Literal objDecimal = m.createTypedLiteral(new BigDecimal(123.4));
Literal objDouble = m.createTypedLiteral(123.4d);
@@ -132,7 +136,8 @@ public abstract class AbstractResultSetT
m.createStatement(subjUri, predUri, objLangLiteral),
// Triples with typed literals as objects
m.createStatement(subjUri, predUri, objBoolean), m.createStatement(subjUri, predUri, objByte),
- m.createStatement(subjUri, predUri, objDate), m.createStatement(subjUri, predUri, objChar),
+ m.createStatement(subjUri, predUri, objDateTime), m.createStatement(subjUri, predUri, objDate),
+ m.createStatement(subjUri, predUri, objTime), m.createStatement(subjUri, predUri, objChar),
m.createStatement(subjUri, predUri, objDecimal), m.createStatement(subjUri, predUri, objDouble),
m.createStatement(subjUri, predUri, objFloat), m.createStatement(subjUri, predUri, objInteger),
m.createStatement(subjUri, predUri, objLong), m.createStatement(subjUri, predUri, objShort),
@@ -310,13 +315,14 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to strings OK
+ * Tests that SELECT result values are appropriately marshalled when using
+ * getObject()
*
* @throws SQLException
*/
@Test
- public void results_select_strings_01() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT (STR(?o) AS ?str) { ?s ?p ?o . FILTER(!ISBLANK(?o)) }");
+ public void results_select_objects_04() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.time.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
@@ -324,8 +330,10 @@ public abstract class AbstractResultSetT
// Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("str"));
+ Object obj = rset.getObject("o");
+ Assert.assertNotNull(obj);
Assert.assertFalse(rset.wasNull());
+ Assert.assertTrue(obj instanceof Time);
}
Assert.assertTrue(rset.isAfterLast());
@@ -334,13 +342,14 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to strings OK
+ * Tests that SELECT result values are appropriately marshalled when using
+ * getObject()
*
* @throws SQLException
*/
@Test
- public void results_select_strings_02() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT (STR(?o) AS ?str) { ?s ?p ?o . FILTER(!ISBLANK(?o)) }");
+ public void results_select_objects_05() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.date.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
@@ -348,8 +357,10 @@ public abstract class AbstractResultSetT
// Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getNString("str"));
+ Object obj = rset.getObject("o");
+ Assert.assertNotNull(obj);
Assert.assertFalse(rset.wasNull());
+ Assert.assertTrue(obj instanceof Date);
}
Assert.assertTrue(rset.isAfterLast());
@@ -358,14 +369,13 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to strings OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_strings_01() throws SQLException {
- ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?str } WHERE { ?s ?p ?o . FILTER(!ISBLANK(?o)) . BIND(STR(?o) AS ?str) }");
+ public void results_select_strings_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT (STR(?o) AS ?str) { ?s ?p ?o . FILTER(!ISBLANK(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
@@ -373,7 +383,7 @@ public abstract class AbstractResultSetT
// Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getString("str"));
Assert.assertFalse(rset.wasNull());
}
@@ -383,14 +393,13 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to strings OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_strings_02() throws SQLException {
- ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?str } WHERE { ?s ?p ?o . FILTER(!ISBLANK(?o)) . BIND(STR(?o) AS ?str) }");
+ public void results_select_strings_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT (STR(?o) AS ?str) { ?s ?p ?o . FILTER(!ISBLANK(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
@@ -398,7 +407,7 @@ public abstract class AbstractResultSetT
// Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getNString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getNString("str"));
Assert.assertFalse(rset.wasNull());
}
@@ -408,25 +417,21 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to numerics OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_select_numerics() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(ISNUMERIC(?o)) }");
+ public void results_select_strings_03() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT (STR(?o) AS ?str) { ?s ?p ?o . FILTER(!ISBLANK(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal big decimal OK
- BigDecimal zero = new BigDecimal(0);
+ // Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- // Use decimal since all numeric types should be promotable to
- // decimal
- Assert.assertFalse(rset.getBigDecimal("o").equals(zero));
+ Assert.assertNotNull(rset.getString(1));
Assert.assertFalse(rset.wasNull());
}
@@ -436,25 +441,21 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to numerics OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_numerics() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(ISNUMERIC(?o)) }");
+ public void results_select_strings_04() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT (STR(?o) AS ?str) { ?s ?p ?o . FILTER(!ISBLANK(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal big decimal OK
- BigDecimal zero = new BigDecimal(0);
+ // Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- // Use decimal since all numeric types should be promotable to
- // decimal
- Assert.assertFalse(rset.getBigDecimal(TripleResultsMetadata.COLUMN_LABEL_OBJECT).equals(zero));
+ Assert.assertNotNull(rset.getNString(1));
Assert.assertFalse(rset.wasNull());
}
@@ -464,23 +465,22 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to integers OK
+ * Tests that CONSTRUCT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_select_integers() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getIntegerTypeUri()
- + ">) }");
+ public void results_construct_strings_01() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?str } WHERE { ?s ?p ?o . FILTER(!ISBLANK(?o)) . BIND(STR(?o) AS ?str) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal integers OK
+ // Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertFalse(0 == rset.getInt("o"));
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -490,23 +490,22 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to integers OK
+ * Tests that CONSTRUCT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_integers() throws SQLException {
+ public void results_construct_strings_02() throws SQLException {
ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getIntegerTypeUri() + ">) }");
+ "CONSTRUCT { ?s ?p ?str } WHERE { ?s ?p ?o . FILTER(!ISBLANK(?o)) . BIND(STR(?o) AS ?str) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal integers OK
+ // Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertFalse(0 == rset.getInt(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getNString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -516,23 +515,22 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to bytes OK
+ * Tests that CONSTRUCT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_select_bytes() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri()
- + "> && ?o <= 255) }");
+ public void results_construct_strings_03() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?str } WHERE { ?s ?p ?o . FILTER(!ISBLANK(?o)) . BIND(STR(?o) AS ?str) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal bytes OK
+ // Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertFalse((byte) 0 == rset.getByte("o"));
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -542,24 +540,22 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to bytes OK
+ * Tests that CONSTRUCT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_bytes() throws SQLException {
- ResultSet rset = this
- .createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri()
- + "> && ?o <= 255) }");
+ public void results_construct_strings_04() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?str } WHERE { ?s ?p ?o . FILTER(!ISBLANK(?o)) . BIND(STR(?o) AS ?str) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal bytes OK
+ // Check all rows allow us to marshal strings OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertFalse((byte) 0 == rset.getByte(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getNString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -569,23 +565,21 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to floats OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_select_floats() throws SQLException {
- ResultSet rset = this
- .createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xfloat.toString() + ">) }");
+ public void results_select_urls_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?s { ?s ?p ?o . FILTER(ISURI(?s)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal floats OK
+ // Check all rows allow us to marshal URLs OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertFalse(0f == rset.getFloat("o"));
+ Assert.assertNotNull(rset.getURL("s"));
Assert.assertFalse(rset.wasNull());
}
@@ -595,23 +589,21 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to floats OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_floats() throws SQLException {
- ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xfloat.toString() + ">) }");
+ public void results_select_urls_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?s { ?s ?p ?o . FILTER(ISURI(?s)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal floats OK
+ // Check all rows allow us to marshal URLs OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertFalse(0f == rset.getFloat(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getURL(1));
Assert.assertFalse(rset.wasNull());
}
@@ -621,23 +613,21 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to doubles OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_select_doubles() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xdouble.toString()
- + ">) }");
+ public void results_construct_urls_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(ISURI(?s)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal doubles OK
+ // Check all rows allow us to marshal URLs OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertFalse(0d == rset.getDouble("o"));
+ Assert.assertNotNull(rset.getURL(TripleResultsMetadata.COLUMN_LABEL_SUBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -647,23 +637,21 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to doubles OK
+ * Tests that SELECT result values can be marshalled to strings OK
*
* @throws SQLException
*/
@Test
- public void results_construct_doubles() throws SQLException {
- ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xdouble.toString() + ">) }");
+ public void results_construct_urls_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(ISURI(?s)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal doubles OK
+ // Check all rows allow us to marshal URLs OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertFalse(0d == rset.getDouble(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getURL(TripleResultsMetadata.COLUMN_INDEX_SUBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -673,23 +661,25 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to longs OK
+ * Tests that SELECT result values can be marshalled to numerics OK
*
* @throws SQLException
*/
@Test
- public void results_select_longs() throws SQLException {
- ResultSet rset = this
- .createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getLongTypeUri() + ">) }");
+ public void results_select_numeric_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(ISNUMERIC(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal longs OK
+ // Check all rows allow us to marshal big decimal OK
+ BigDecimal zero = new BigDecimal(0);
while (rset.next()) {
Assert.assertNotNull(rset.getString("o"));
- Assert.assertFalse(0l == rset.getLong("o"));
+ // Use decimal since all numeric types should be promotable to
+ // decimal
+ Assert.assertFalse(rset.getBigDecimal("o").equals(zero));
Assert.assertFalse(rset.wasNull());
}
@@ -699,23 +689,25 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to longs OK
+ * Tests that SELECT result values can be marshalled to numerics OK
*
* @throws SQLException
*/
@Test
- public void results_construct_longs() throws SQLException {
- ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getLongTypeUri() + ">) }");
+ public void results_select_numeric_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(ISNUMERIC(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal longs OK
+ // Check all rows allow us to marshal big decimal OK
+ BigDecimal zero = new BigDecimal(0);
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertFalse(0l == rset.getLong(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getString(1));
+ // Use decimal since all numeric types should be promotable to
+ // decimal
+ Assert.assertFalse(rset.getBigDecimal(1).equals(zero));
Assert.assertFalse(rset.wasNull());
}
@@ -725,23 +717,25 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to shorts OK
+ * Tests that CONSTRUCT result values can be marshalled to numerics OK
*
* @throws SQLException
*/
@Test
- public void results_select_shorts() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getShortTypeUri()
- + ">) }");
+ public void results_construct_numerics_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(ISNUMERIC(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal shorts OK
+ // Check all rows allow us to marshal big decimal OK
+ BigDecimal zero = new BigDecimal(0);
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertFalse((short) 0 == rset.getShort("o"));
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ // Use decimal since all numeric types should be promotable to
+ // decimal
+ Assert.assertFalse(rset.getBigDecimal(TripleResultsMetadata.COLUMN_LABEL_OBJECT).equals(zero));
Assert.assertFalse(rset.wasNull());
}
@@ -751,23 +745,25 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to shorts OK
+ * Tests that CONSTRUCT result values can be marshalled to numerics OK
*
* @throws SQLException
*/
@Test
- public void results_construct_shorts() throws SQLException {
- ResultSet rset = this.createResults(ds,
- "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getShortTypeUri() + ">) }");
+ public void results_construct_numerics_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(ISNUMERIC(?o)) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal shorts OK
+ // Check all rows allow us to marshal big decimal OK
+ BigDecimal zero = new BigDecimal(0);
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertFalse((short) 0 == rset.getShort(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ // Use decimal since all numeric types should be promotable to
+ // decimal
+ Assert.assertFalse(rset.getBigDecimal(TripleResultsMetadata.COLUMN_INDEX_OBJECT).equals(zero));
Assert.assertFalse(rset.wasNull());
}
@@ -777,23 +773,23 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to dates OK
+ * Tests that SELECT result values can be marshalled to integers OK
*
* @throws SQLException
*/
@Test
- public void results_select_dates_01() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ public void results_select_integers_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getIntegerTypeUri()
+ ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal strings OK
+ // Check all rows allow us to marshal integers OK
while (rset.next()) {
Assert.assertNotNull(rset.getString("o"));
- Assert.assertNotNull(rset.getDate("o"));
+ Assert.assertFalse(0 == rset.getInt("o"));
Assert.assertFalse(rset.wasNull());
}
@@ -803,23 +799,23 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to dates OK
+ * Tests that SELECT result values can be marshalled to integers OK
*
* @throws SQLException
*/
@Test
- public void results_select_dates_02() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ public void results_select_integers_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getIntegerTypeUri()
+ ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal strings OK
+ // Check all rows allow us to marshal integers OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertNotNull(rset.getTime("o"));
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertFalse(0 == rset.getInt(1));
Assert.assertFalse(rset.wasNull());
}
@@ -829,23 +825,23 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that SELECT result values can be marshalled to dates OK
+ * Tests that CONSTRUCT result values can be marshalled to integers OK
*
* @throws SQLException
*/
@Test
- public void results_select_dates_03() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
- + ">) }");
+ public void results_construct_integers_01() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getIntegerTypeUri() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal strings OK
+ // Check all rows allow us to marshal integers OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString("o"));
- Assert.assertNotNull(rset.getTimestamp("o"));
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(0 == rset.getInt(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -855,23 +851,23 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to dates OK
+ * Tests that CONSTRUCT result values can be marshalled to integers OK
*
* @throws SQLException
*/
@Test
- public void results_construct_dates_01() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <"
- + XSD.dateTime.toString() + ">) }");
+ public void results_construct_integers_02() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getIntegerTypeUri() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal strings OK
+ // Check all rows allow us to marshal integers OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertNotNull(rset.getDate(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(0 == rset.getInt(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
Assert.assertFalse(rset.wasNull());
}
@@ -881,23 +877,23 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to dates OK
+ * Tests that SELECT result values can be marshalled to bytes OK
*
* @throws SQLException
*/
@Test
- public void results_construct_dates_02() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <"
- + XSD.dateTime.toString() + ">) }");
+ public void results_select_bytes_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri()
+ + "> && ?o <= 255) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal strings OK
+ // Check all rows allow us to marshal bytes OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertNotNull(rset.getTime(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertFalse((byte) 0 == rset.getByte("o"));
Assert.assertFalse(rset.wasNull());
}
@@ -907,23 +903,23 @@ public abstract class AbstractResultSetT
}
/**
- * Tests that CONSTRUCT result values can be marshalled to dates OK
+ * Tests that SELECT result values can be marshalled to bytes OK
*
* @throws SQLException
*/
@Test
- public void results_construct_dates_03() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <"
- + XSD.dateTime.toString() + ">) }");
+ public void results_select_bytes_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri()
+ + "> && ?o <= 255) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Check all rows allow us to marshal strings OK
+ // Check all rows allow us to marshal bytes OK
while (rset.next()) {
- Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
- Assert.assertNotNull(rset.getTimestamp(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertFalse((byte) 0 == rset.getByte(1));
Assert.assertFalse(rset.wasNull());
}
@@ -933,24 +929,26 @@ public abstract class AbstractResultSetT
}
/**
- * Tests movement through SELECT results
+ * Tests that CONSTRUCT result values can be marshalled to bytes OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_01() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_construct_bytes_01() throws SQLException {
+ ResultSet rset = this
+ .createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri()
+ + "> && ?o <= 255) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Expect exactly one row we can move to
- Assert.assertTrue(rset.next());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
+ // Check all rows allow us to marshal bytes OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse((byte) 0 == rset.getByte(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
Assert.assertTrue(rset.isAfterLast());
rset.close();
@@ -958,59 +956,52 @@ public abstract class AbstractResultSetT
}
/**
- * Tests movement through SELECT results
+ * Tests that CONSTRUCT result values can be marshalled to bytes OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_02() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_construct_bytes_02() throws SQLException {
+ ResultSet rset = this
+ .createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri()
+ + "> && ?o <= 255) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Expect exactly one row we can move to
- Assert.assertTrue(rset.next());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
-
- // Attempting to move backwards in a forwards only result set should
- // result in an error
- try {
- rset.beforeFirst();
- Assert.fail("Should not be permitted to move backwards in a FORWARD_ONLY result set");
- } catch (SQLException e) {
- // Expected
- } finally {
-
- Assert.assertTrue(rset.isAfterLast());
- rset.close();
- Assert.assertTrue(rset.isClosed());
+ // Check all rows allow us to marshal bytes OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse((byte) 0 == rset.getByte(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(rset.wasNull());
}
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through SELECT results
+ * Tests that SELECT result values can be marshalled to floats OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_03() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_select_floats_01() throws SQLException {
+ ResultSet rset = this
+ .createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xfloat.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to last row
- Assert.assertTrue(rset.last());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
+ // Check all rows allow us to marshal floats OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertFalse(0f == rset.getFloat("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
Assert.assertTrue(rset.isAfterLast());
rset.close();
@@ -1018,211 +1009,207 @@ public abstract class AbstractResultSetT
}
/**
- * Tests movement through SELECT results
+ * Tests that SELECT result values can be marshalled to floats OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_04() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_select_floats_02() throws SQLException {
+ ResultSet rset = this
+ .createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xfloat.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to after last row
- rset.afterLast();
- Assert.assertTrue(rset.isAfterLast());
+ // Check all rows allow us to marshal floats OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertFalse(0f == rset.getFloat(1));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through SELECT results
+ * Tests that CONSTRUCT result values can be marshalled to floats OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_05() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_construct_floats_01() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xfloat.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Expect exactly one row we can move to
- Assert.assertTrue(rset.next());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
-
- // Attempting to move backwards in a scrollable result set should result
- // set should be fine
- rset.beforeFirst();
- Assert.assertTrue(rset.isBeforeFirst());
+ // Check all rows allow us to marshal floats OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(0f == rset.getFloat(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through SELECT results
+ * Tests that CONSTRUCT result values can be marshalled to floats OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_06() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_construct_floats_02() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xfloat.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to first row
- Assert.assertTrue(rset.next());
- Assert.assertTrue(rset.isFirst());
- Assert.assertFalse(rset.isLast());
-
- // Then can move forwards to second row
- Assert.assertTrue(rset.next());
- Assert.assertTrue(rset.isLast());
-
- // Can move backwards to previous row
- Assert.assertTrue(rset.previous());
- Assert.assertTrue(rset.isFirst());
+ // Check all rows allow us to marshal floats OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(0f == rset.getFloat(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through SELECT results
+ * Tests that SELECT result values can be marshalled to doubles OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_07() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 5", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_select_doubles_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xdouble.toString()
+ + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move to various absolute rows
- Assert.assertTrue(rset.absolute(1));
- Assert.assertTrue(rset.absolute(1));
- Assert.assertTrue(rset.absolute(3));
- Assert.assertTrue(rset.absolute(2));
- Assert.assertTrue(rset.absolute(4));
- Assert.assertTrue(rset.absolute(5));
- Assert.assertTrue(rset.absolute(-1));
- Assert.assertTrue(rset.absolute(-2));
- Assert.assertTrue(rset.absolute(-3));
- Assert.assertTrue(rset.absolute(-4));
- Assert.assertTrue(rset.absolute(-5));
-
- // 0 is treated as moving to before first
- Assert.assertFalse(rset.absolute(0));
- Assert.assertTrue(rset.isBeforeFirst());
-
- // 1 is treated as moving to first row
- Assert.assertTrue(rset.absolute(1));
- Assert.assertTrue(rset.isFirst());
-
- // -1 is treated as moving to last row
- Assert.assertTrue(rset.absolute(-1));
- Assert.assertTrue(rset.isLast());
+ // Check all rows allow us to marshal doubles OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertFalse(0d == rset.getDouble("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
- // Moving to a row beyond end positions us after last and returns false
- Assert.assertFalse(rset.absolute(6));
Assert.assertTrue(rset.isAfterLast());
-
- // Moving to a row before start positions us before first and returns
- // false
- Assert.assertFalse(rset.absolute(-6));
- Assert.assertTrue(rset.isBeforeFirst());
-
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through SELECT results
+ * Tests that SELECT result values can be marshalled to doubles OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_08() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_select_doubles_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xdouble.toString()
+ + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to after last row
- rset.afterLast();
- Assert.assertTrue(rset.isAfterLast());
-
- // Can move backwards to last row
- Assert.assertTrue(rset.last());
- Assert.assertTrue(rset.isLast());
+ // Check all rows allow us to marshal doubles OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertFalse(0d == rset.getDouble(1));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through SELECT results
+ * Tests that CONSTRUCT result values can be marshalled to doubles OK
*
* @throws SQLException
*/
@Test
- public void results_select_movement_09() throws SQLException {
- ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_construct_doubles_01() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xdouble.toString() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to after last row
- rset.afterLast();
+ // Check all rows allow us to marshal doubles OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(0d == rset.getDouble(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+
Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
- // Moving backwards more rows than possible with relative movement
- // should place us before first row
- Assert.assertFalse(rset.relative(-4));
+ /**
+ * Tests that CONSTRUCT result values can be marshalled to doubles OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_doubles_02() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xdouble.toString() + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal doubles OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(0d == rset.getDouble(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that SELECT result values can be marshalled to longs OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_01() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_select_longs_01() throws SQLException {
+ ResultSet rset = this
+ .createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getLongTypeUri() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Expect exactly one row we can move to
- Assert.assertTrue(rset.next());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
+ // Check all rows allow us to marshal longs OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertFalse(0l == rset.getLong("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
Assert.assertTrue(rset.isAfterLast());
rset.close();
@@ -1230,59 +1217,77 @@ public abstract class AbstractResultSetT
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that SELECT result values can be marshalled to longs OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_02() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_select_longs_02() throws SQLException {
+ ResultSet rset = this
+ .createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getLongTypeUri() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Expect exactly one row we can move to
- Assert.assertTrue(rset.next());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
-
- // Attempting to move backwards in a forwards only result set should
- // result in an error
- try {
- rset.beforeFirst();
- Assert.fail("Should not be permitted to move backwards in a FORWARD_ONLY result set");
- } catch (SQLException e) {
- // Expected
- } finally {
+ // Check all rows allow us to marshal longs OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertFalse(0l == rset.getLong(1));
+ Assert.assertFalse(rset.wasNull());
+ }
- Assert.assertTrue(rset.isAfterLast());
- rset.close();
- Assert.assertTrue(rset.isClosed());
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that CONSTRUCT result values can be marshalled to longs OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_longs_01() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getLongTypeUri() + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal longs OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(0l == rset.getLong(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
}
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that CONSTRUCT result values can be marshalled to longs OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_03() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_construct_longs_02() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getLongTypeUri() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to last row
- Assert.assertTrue(rset.last());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
+ // Check all rows allow us to marshal longs OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(0l == rset.getLong(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
Assert.assertTrue(rset.isAfterLast());
rset.close();
@@ -1290,229 +1295,1652 @@ public abstract class AbstractResultSetT
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that SELECT result values can be marshalled to shorts OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_04() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
- Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ public void results_select_shorts_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getShortTypeUri()
+ + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to after last row
- rset.afterLast();
+ // Check all rows allow us to marshal shorts OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertFalse((short) 0 == rset.getShort("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
+
Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to shorts OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_shorts_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getShortTypeUri()
+ + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal shorts OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertFalse((short) 0 == rset.getShort(1));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that SELECT result values can be marshalled to shorts OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_05() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_construct_shorts_01() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getShortTypeUri() + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Expect exactly one row we can move to
- Assert.assertTrue(rset.next());
- Assert.assertFalse(rset.isAfterLast());
- Assert.assertTrue(rset.isLast());
- Assert.assertFalse(rset.next());
+ // Check all rows allow us to marshal shorts OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse((short) 0 == rset.getShort(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
- // Attempting to move backwards in a scrollable result set should result
- // set should be fine
- rset.beforeFirst();
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to shorts OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_shorts_02() throws SQLException {
+ ResultSet rset = this.createResults(ds,
+ "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getShortTypeUri() + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal shorts OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse((short) 0 == rset.getShort(TripleResultsMetadata.COLUMN_INDEX_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that SELECT result values can be marshalled to boolean OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_06() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_select_boolean_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "PREFIX xsd: <" + XSD.getURI()
+ + "> SELECT ?bool { ?s ?p ?o . BIND(xsd:boolean(?o) AS ?bool) . }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move forwards to first row
- Assert.assertTrue(rset.next());
- Assert.assertTrue(rset.isFirst());
+ // Check all rows allow us to marshal big decimal OK
+ while (rset.next()) {
+ boolean b = rset.getBoolean("bool");
+ if (!rset.wasNull()) {
+ Assert.assertTrue(b || !b);
+ Assert.assertFalse(rset.wasNull());
+ } else {
+ Assert.assertTrue(rset.wasNull());
+ }
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to numerics OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_boolean_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "PREFIX xsd: <" + XSD.getURI()
+ + "> SELECT ?bool { ?s ?p ?o . BIND(xsd:boolean(?o) AS ?bool) . }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Then can move forwards to second row
- Assert.assertTrue(rset.next());
- Assert.assertTrue(rset.isLast());
+ // Check all rows allow us to marshal big decimal OK
+ while (rset.next()) {
+ boolean b = rset.getBoolean(1);
+ if (!rset.wasNull()) {
+ Assert.assertTrue(b || !b);
+ Assert.assertFalse(rset.wasNull());
+ } else {
+ Assert.assertTrue(rset.wasNull());
+ }
+ }
- // Can move backwards to previous row
- Assert.assertTrue(rset.previous());
- Assert.assertTrue(rset.isFirst());
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_dates_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertNotNull(rset.getDate("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
+ Assert.assertTrue(rset.isAfterLast());
rset.close();
Assert.assertTrue(rset.isClosed());
}
/**
- * Tests movement through CONSTRUCT results
+ * Tests that SELECT result values can be marshalled to dates OK
*
* @throws SQLException
*/
@Test
- public void results_construct_movement_07() throws SQLException {
- ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 5", ResultSet.TYPE_SCROLL_INSENSITIVE);
- Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ public void results_select_dates_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ + ">) }");
Assert.assertNotNull(rset);
Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
Assert.assertFalse(rset.isLast());
- // Can move to various absolute rows
- Assert.assertTrue(rset.absolute(1));
- Assert.assertTrue(rset.absolute(1));
- Assert.assertTrue(rset.absolute(3));
- Assert.assertTrue(rset.absolute(2));
- Assert.assertTrue(rset.absolute(4));
- Assert.assertTrue(rset.absolute(5));
- Assert.assertTrue(rset.absolute(-1));
- Assert.assertTrue(rset.absolute(-2));
- Assert.assertTrue(rset.absolute(-3));
- Assert.assertTrue(rset.absolute(-4));
- Assert.assertTrue(rset.absolute(-5));
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertNotNull(rset.getTime("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
- // 0 is treated as moving to before first
- Assert.assertFalse(rset.absolute(0));
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_dates_03() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
- // 1 is treated as moving to first row
- Assert.assertTrue(rset.absolute(1));
- Assert.assertTrue(rset.isFirst());
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString("o"));
+ Assert.assertNotNull(rset.getTimestamp("o"));
+ Assert.assertFalse(rset.wasNull());
+ }
- // -1 is treated as moving to last row
- Assert.assertTrue(rset.absolute(-1));
- Assert.assertTrue(rset.isLast());
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_dates_04() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertNotNull(rset.getDate(1));
+ Assert.assertFalse(rset.wasNull());
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_dates_05() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertNotNull(rset.getTime(1));
+ Assert.assertFalse(rset.wasNull());
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that SELECT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_dates_06() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.dateTime.toString()
+ + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(1));
+ Assert.assertNotNull(rset.getTimestamp(1));
+ Assert.assertFalse(rset.wasNull());
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that CONSTRUCT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_dates_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <"
+ + XSD.dateTime.toString() + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getDate(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that CONSTRUCT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_dates_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <"
+ + XSD.dateTime.toString() + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getTime(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests that CONSTRUCT result values can be marshalled to dates OK
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_dates_03() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o . FILTER(DATATYPE(?o) = <"
+ + XSD.dateTime.toString() + ">) }");
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Check all rows allow us to marshal strings OK
+ while (rset.next()) {
+ Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertNotNull(rset.getTimestamp(TripleResultsMetadata.COLUMN_LABEL_OBJECT));
+ Assert.assertFalse(rset.wasNull());
+ }
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Expect exactly one row we can move to
+ Assert.assertTrue(rset.next());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Expect exactly one row we can move to
+ Assert.assertTrue(rset.next());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ // Attempting to move backwards in a forwards only result set should
+ // result in an error
+ try {
+ rset.beforeFirst();
+ Assert.fail("Should not be permitted to move backwards in a FORWARD_ONLY result set");
+ } catch (SQLException e) {
+ // Expected
+ } finally {
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_03() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move forwards to last row
+ Assert.assertTrue(rset.last());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_04() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move forwards to after last row
+ rset.afterLast();
+ Assert.assertTrue(rset.isAfterLast());
+
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_05() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_SCROLL_INSENSITIVE);
+ Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Expect exactly one row we can move to
+ Assert.assertTrue(rset.next());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ // Attempting to move backwards in a scrollable result set should result
+ // set should be fine
+ rset.beforeFirst();
+ Assert.assertTrue(rset.isBeforeFirst());
+
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_06() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
+ Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move forwards to first row
+ Assert.assertTrue(rset.next());
+ Assert.assertTrue(rset.isFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Then can move forwards to second row
+ Assert.assertTrue(rset.next());
+ Assert.assertTrue(rset.isLast());
+
+ // Can move backwards to previous row
+ Assert.assertTrue(rset.previous());
+ Assert.assertTrue(rset.isFirst());
+
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_07() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 5", ResultSet.TYPE_SCROLL_INSENSITIVE);
+ Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move to various absolute rows
+ Assert.assertTrue(rset.absolute(1));
+ Assert.assertTrue(rset.absolute(1));
+ Assert.assertTrue(rset.absolute(3));
+ Assert.assertTrue(rset.absolute(2));
+ Assert.assertTrue(rset.absolute(4));
+ Assert.assertTrue(rset.absolute(5));
+ Assert.assertTrue(rset.absolute(-1));
+ Assert.assertTrue(rset.absolute(-2));
+ Assert.assertTrue(rset.absolute(-3));
+ Assert.assertTrue(rset.absolute(-4));
+ Assert.assertTrue(rset.absolute(-5));
+
+ // 0 is treated as moving to before first
+ Assert.assertFalse(rset.absolute(0));
+ Assert.assertTrue(rset.isBeforeFirst());
+
+ // 1 is treated as moving to first row
+ Assert.assertTrue(rset.absolute(1));
+ Assert.assertTrue(rset.isFirst());
+
+ // -1 is treated as moving to last row
+ Assert.assertTrue(rset.absolute(-1));
+ Assert.assertTrue(rset.isLast());
+
+ // Moving to a row beyond end positions us after last and returns false
+ Assert.assertFalse(rset.absolute(6));
+ Assert.assertTrue(rset.isAfterLast());
+
+ // Moving to a row before start positions us before first and returns
+ // false
+ Assert.assertFalse(rset.absolute(-6));
+ Assert.assertTrue(rset.isBeforeFirst());
+
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_08() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
+ Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move forwards to after last row
+ rset.afterLast();
+ Assert.assertTrue(rset.isAfterLast());
+
+ // Can move backwards to last row
+ Assert.assertTrue(rset.last());
+ Assert.assertTrue(rset.isLast());
+
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through SELECT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_select_movement_09() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * { ?s ?p ?o . } LIMIT 2", ResultSet.TYPE_SCROLL_INSENSITIVE);
+ Assert.assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move forwards to after last row
+ rset.afterLast();
+ Assert.assertTrue(rset.isAfterLast());
+
+ // Moving backwards more rows than possible with relative movement
+ // should place us before first row
+ Assert.assertFalse(rset.relative(-4));
+ Assert.assertTrue(rset.isBeforeFirst());
+
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through CONSTRUCT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_movement_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Expect exactly one row we can move to
+ Assert.assertTrue(rset.next());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through CONSTRUCT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_movement_02() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Expect exactly one row we can move to
+ Assert.assertTrue(rset.next());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ // Attempting to move backwards in a forwards only result set should
+ // result in an error
+ try {
+ rset.beforeFirst();
+ Assert.fail("Should not be permitted to move backwards in a FORWARD_ONLY result set");
+ } catch (SQLException e) {
+ // Expected
+ } finally {
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+ }
+
+ /**
+ * Tests movement through CONSTRUCT results
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_construct_movement_03() throws SQLException {
+ ResultSet rset = this.createResults(ds, "CONSTRUCT WHERE { ?s ?p ?o . } LIMIT 1", ResultSet.TYPE_FORWARD_ONLY);
+ Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rset.getType());
+ Assert.assertNotNull(rset);
+ Assert.assertFalse(rset.isClosed());
+ Assert.assertTrue(rset.isBeforeFirst());
+ Assert.assertFalse(rset.isLast());
+
+ // Can move forwards to last row
+ Assert.assertTrue(rset.last());
+ Assert.assertFalse(rset.isAfterLast());
+ Assert.assertTrue(rset.isLast());
+ Assert.assertFalse(rset.next());
+
+ Assert.assertTrue(rset.isAfterLast());
+ rset.close();
+ Assert.assertTrue(rset.isClosed());
+ }
+
+ /**
+ * Tests movement through CONSTRUCT results
+ *
+ * @throws SQLException
+ */
+ @Test
[... 2792 lines stripped ...]