| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.jena.jdbc.results; |
| |
| import java.io.InputStream ; |
| import java.io.Reader ; |
| import java.math.BigDecimal ; |
| import java.sql.* ; |
| import java.util.Calendar ; |
| import java.util.HashMap ; |
| |
| import org.apache.jena.datatypes.TypeMapper ; |
| import org.apache.jena.datatypes.xsd.XSDDatatype ; |
| import org.apache.jena.jdbc.JdbcCompatibility ; |
| import org.apache.jena.jdbc.results.metadata.AskResultsMetadata ; |
| import org.apache.jena.jdbc.results.metadata.TripleResultsMetadata ; |
| import org.apache.jena.query.Dataset ; |
| import org.apache.jena.query.DatasetFactory ; |
| import org.apache.jena.rdf.model.* ; |
| import org.apache.jena.rdf.model.Statement ; |
| import org.apache.jena.sparql.util.NodeFactoryExtra ; |
| import org.apache.jena.sys.JenaSystem ; |
| import org.apache.jena.vocabulary.XSD ; |
| import org.junit.* ; |
| |
| /** |
| * Abstract tests for Jena JDBC {@link ResultSet} implementations, these tests |
| * assume that implementations use the {@link JdbcCompatibility#HIGH} |
| * compatibility level |
| * |
| */ |
| @SuppressWarnings("resource") |
| public abstract class AbstractResultSetTests { |
| |
| static { |
| JenaSystem.init(); |
| } |
| |
| private static Dataset empty, ds; |
| |
| /** |
| * Sets up the datasets used for the tests |
| */ |
| @BeforeClass |
| public static void globalSetup() { |
| // Empty dataset |
| if (empty == null) { |
| empty = DatasetFactory.create(); |
| } |
| |
| // Build a dataset that has one of every type we expect to |
| // commonly see |
| if (ds == null) { |
| ds = DatasetFactory.create(); |
| |
| // Create model and our RDF terms |
| Model m = ModelFactory.createDefaultModel(); |
| Resource subjUri = m.createResource("http://example/subject"); |
| Resource subjBlank = m.createResource(); |
| Property predUri = m.createProperty("http://example/predicate"); |
| Resource objUri = m.createResource("http://example/object"); |
| Resource objBlank = m.createResource(); |
| Literal objSimpleLiteral = m.createLiteral("simple"); |
| Literal objLangLiteral = m.createLiteral("simple", "en"); |
| Literal objBoolean = m.createTypedLiteral(true); |
| Literal objByte = m.createTypedLiteral(Byte.toString((byte) 123), XSDDatatype.XSDbyte); |
| 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); |
| Literal objFloat = m.createTypedLiteral(123.4f); |
| Literal objInteger = m.createTypedLiteral(1234); |
| Literal objLong = m.createTypedLiteral(1234l); |
| Literal objShort = m.createTypedLiteral(Short.toString((short) 123), XSDDatatype.XSDshort); |
| Literal objString = m.createTypedLiteral("typed"); |
| Literal objCustom = m.createTypedLiteral("custom", |
| TypeMapper.getInstance().getSafeTypeByName("http://example/customType")); |
| |
| m.add(new Statement[] { |
| // Simple triples with URIs and Blank Nodes only |
| m.createStatement(subjUri, predUri, objUri), |
| m.createStatement(subjUri, predUri, objBlank), |
| m.createStatement(subjBlank, predUri, objUri), |
| m.createStatement(subjBlank, predUri, objBlank), |
| // Simple triples with simple literals as objects |
| m.createStatement(subjUri, predUri, objSimpleLiteral), |
| 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, 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), |
| m.createStatement(subjUri, predUri, objString), m.createStatement(subjUri, predUri, objCustom) }); |
| ds.setDefaultModel(m); |
| } |
| } |
| |
| /** |
| * Cleans up the datasets used for tests |
| */ |
| @AfterClass |
| public static void globalTeardown() { |
| ds.close(); |
| ds = null; |
| empty.close(); |
| empty = null; |
| } |
| |
| protected abstract ResultSet createResults(Dataset ds, String query) throws SQLException; |
| |
| protected abstract ResultSet createResults(Dataset ds, String query, int resultSetType) throws SQLException; |
| |
| protected String getIntegerTypeUri() { |
| return XSD.xint.toString(); |
| } |
| |
| protected String getByteTypeUri() { |
| return XSD.xbyte.toString(); |
| } |
| |
| protected String getShortTypeUri() { |
| return XSD.xshort.toString(); |
| } |
| |
| protected String getLongTypeUri() { |
| return XSD.xlong.toString(); |
| } |
| |
| /** |
| * Test ASK results with a true result |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_ask_true() throws SQLException { |
| ResultSet rset = this.createResults(AbstractResultSetTests.empty, "ASK { }"); |
| Assert.assertNotNull(rset); |
| Assert.assertFalse(rset.isClosed()); |
| Assert.assertTrue(rset.isBeforeFirst()); |
| |
| // Try to move to the result row |
| Assert.assertTrue(rset.next()); |
| |
| // Check the boolean return value |
| Assert.assertTrue(rset.getBoolean(AskResultsMetadata.COLUMN_LABEL_ASK)); |
| |
| // Check no further rows |
| Assert.assertFalse(rset.next()); |
| Assert.assertTrue(rset.isAfterLast()); |
| |
| // Close and clean up |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Test ASK results with a false result |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_ask_false() throws SQLException { |
| ResultSet rset = this.createResults(AbstractResultSetTests.empty, "ASK { FILTER(false) }"); |
| Assert.assertNotNull(rset); |
| Assert.assertFalse(rset.isClosed()); |
| Assert.assertTrue(rset.isBeforeFirst()); |
| |
| // Try to move to the result row |
| Assert.assertTrue(rset.next()); |
| |
| // Check the boolean return value |
| Assert.assertFalse(rset.getBoolean(AskResultsMetadata.COLUMN_LABEL_ASK)); |
| |
| // Check no further rows |
| Assert.assertFalse(rset.next()); |
| Assert.assertTrue(rset.isAfterLast()); |
| |
| // Close and clean up |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_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()); |
| Assert.assertFalse(rset.isLast()); |
| |
| // Check all rows allow us to obtain appropriately typed values |
| while (rset.next()) { |
| Object obj = rset.getObject("str"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof String); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_02() throws SQLException { |
| /* Ordering the numbers is important to ensure we get the right type as first result. |
| * When org.apache.jena.jdbc.JdbcCompatibility.HIGH is used, the first result is used |
| * to determine the type of the column. |
| */ |
| |
| ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(ISNUMERIC(?o)) } ORDER BY DESC(?o)"); |
| Assert.assertNotNull(rset); |
| Assert.assertFalse(rset.isClosed()); |
| Assert.assertTrue(rset.isBeforeFirst()); |
| Assert.assertFalse(rset.isLast()); |
| |
| // Check all rows allow us to obtain appropriately typed values |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Long || obj instanceof Integer || obj instanceof Short || obj instanceof Byte |
| || obj instanceof BigDecimal || obj instanceof Double || obj instanceof Float); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_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()); |
| |
| // Check all rows allow us to marshal strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Timestamp); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| Assert.assertFalse(rset.isLast()); |
| |
| // Check all rows allow us to marshal strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Time); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| Assert.assertFalse(rset.isLast()); |
| |
| // Check all rows allow us to marshal strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Date); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_06() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + XSD.xboolean.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()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Boolean); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_07() 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()); |
| |
| // Check all rows allow us to marshal strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Long); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_08() 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()); |
| |
| // Check all rows allow us to marshal strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Double); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_09() 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()); |
| |
| // Check all rows allow us to marshal strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Float); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_10() throws SQLException { |
| Assume.assumeTrue(this.getShortTypeUri().equals(XSD.xshort.getURI())); |
| |
| 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 strings OK |
| while (rset.next()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Integer); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values are appropriately marshalled when using |
| * getObject() |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_select_objects_11() throws SQLException { |
| Assume.assumeTrue(this.getByteTypeUri().equals(XSD.xbyte.getURI())); |
| |
| ResultSet rset = this.createResults(ds, "SELECT ?o { ?s ?p ?o . FILTER(DATATYPE(?o) = <" + this.getByteTypeUri() + ">) }"); |
| 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()) { |
| Object obj = rset.getObject("o"); |
| Assert.assertNotNull(obj); |
| Assert.assertFalse(rset.wasNull()); |
| Assert.assertTrue(obj instanceof Byte); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @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)) }"); |
| 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("str")); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @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)) }"); |
| 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.getNString("str")); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 strings OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString(1)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 strings OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getNString(1)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT 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) }"); |
| 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.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT 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) }"); |
| 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.getNString(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 strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 strings OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 strings OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getNString(TripleResultsMetadata.COLUMN_INDEX_OBJECT)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 URLs OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getURL("s")); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 URLs OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getURL(1)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 URLs OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getURL(TripleResultsMetadata.COLUMN_LABEL_SUBJECT)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to strings OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 URLs OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getURL(TripleResultsMetadata.COLUMN_INDEX_SUBJECT)); |
| Assert.assertFalse(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_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 big decimal OK |
| BigDecimal zero = new BigDecimal(0); |
| 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.assertFalse(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_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 big decimal OK |
| BigDecimal zero = new BigDecimal(0); |
| while (rset.next()) { |
| 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()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT result values can be marshalled to numerics OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 big decimal OK |
| BigDecimal zero = new BigDecimal(0); |
| 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.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT result values can be marshalled to numerics OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 big decimal OK |
| BigDecimal zero = new BigDecimal(0); |
| while (rset.next()) { |
| 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()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to integers OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 integers OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString("o")); |
| Assert.assertFalse(0 == rset.getInt("o")); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to integers OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 integers OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString(1)); |
| Assert.assertFalse(0 == rset.getInt(1)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT result values can be marshalled to integers OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 integers OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_LABEL_OBJECT)); |
| Assert.assertFalse(0 == rset.getInt(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 integers OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 integers OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString(TripleResultsMetadata.COLUMN_INDEX_OBJECT)); |
| Assert.assertFalse(0 == rset.getInt(TripleResultsMetadata.COLUMN_INDEX_OBJECT)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to bytes OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 bytes OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString("o")); |
| Assert.assertFalse((byte) 0 == rset.getByte("o")); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to bytes OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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 bytes OK |
| while (rset.next()) { |
| Assert.assertNotNull(rset.getString(1)); |
| Assert.assertFalse((byte) 0 == rset.getByte(1)); |
| Assert.assertFalse(rset.wasNull()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT result values can be marshalled to bytes OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that CONSTRUCT result values can be marshalled to bytes OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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 that SELECT result values can be marshalled to floats OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to floats OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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 that CONSTRUCT result values can be marshalled to floats OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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 that CONSTRUCT result values can be marshalled to floats OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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 that SELECT result values can be marshalled to doubles OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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()); |
| } |
| |
| Assert.assertTrue(rset.isAfterLast()); |
| rset.close(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to doubles OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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 that CONSTRUCT result values can be marshalled to doubles OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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()); |
| } |
| |
| /** |
| * 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 that SELECT result values can be marshalled to longs OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to longs OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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()); |
| } |
| |
| /** |
| * 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 that CONSTRUCT result values can be marshalled to longs OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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(); |
| Assert.assertTrue(rset.isClosed()); |
| } |
| |
| /** |
| * Tests that SELECT result values can be marshalled to shorts OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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 that SELECT result values can be marshalled to shorts OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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()); |
| } |
| |
| 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 that SELECT result values can be marshalled to boolean OK |
| * |
| * @throws SQLException |
| */ |
| @Test |
| 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()); |
| |
| // 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()); |
| |
| // 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()); |
| } |
| } |
| |
| 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 that SELECT result values can be marshalled to dates 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() |
| + ">) }"); |
| 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.getTime("o")); |
| 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_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()); |
| |
| // 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()); |
| } |
| |
| 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 |
| 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()); |
| 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 CONSTRUCT results |
| * |
| * @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()); |
| 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 CONSTRUCT results |
| * |
| * @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()); |
| 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 CONSTRUCT results |
| * |
| * @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()); |
| 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 CONSTRUCT results |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_construct_movement_08() 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()); |
| 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_construct_movement_09() 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()); |
| 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()); |
| } |
| |
| /** |
| * Test error cases for creating results |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLException.class) |
| public void results_bad_creation_01() throws SQLException { |
| new AskResults(null, true, false).close(); |
| } |
| |
| /** |
| * Test error cases for unsupported wrapper features |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_wrapper_01() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.isWrapperFor(JenaResultSet.class); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Test error cases for unsupported wrapper features |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_wrapper_02() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.unwrap(JenaResultSet.class); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_01() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.cancelRowUpdates(); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_02() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.deleteRow(); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_03() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.insertRow(); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_04() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.moveToCurrentRow(); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_05() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.moveToInsertRow(); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_bad_updates_06() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| Assert.assertFalse(rset.rowDeleted()); |
| rset.close(); |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_bad_updates_07() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| Assert.assertFalse(rset.rowInserted()); |
| rset.close(); |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_bad_updates_08() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| Assert.assertFalse(rset.rowUpdated()); |
| rset.close(); |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_09() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateArray(1, (Array) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_10() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateArray("s", (Array) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_11() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateAsciiStream(1, (InputStream) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_12() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateAsciiStream("s", (InputStream) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_13() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateAsciiStream(1, (InputStream) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_14() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateAsciiStream("s", (InputStream) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_15() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateAsciiStream(1, (InputStream) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_16() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateAsciiStream("s", (InputStream) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_18() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBigDecimal(1, (BigDecimal) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_17() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBigDecimal("s", (BigDecimal) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_19() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBinaryStream(1, (InputStream) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_20() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBinaryStream("s", (InputStream) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_21() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBinaryStream(1, (InputStream) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_22() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBinaryStream("s", (InputStream) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_23() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBinaryStream(1, (InputStream) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_24() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBinaryStream("s", (InputStream) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_25() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBlob(1, (Blob) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_26() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBlob("s", (Blob) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_27() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBlob(1, (InputStream) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_28() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBlob("s", (InputStream) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_29() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBlob(1, (InputStream) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_30() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBlob("s", (InputStream) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_31() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBoolean(1, true); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_32() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBoolean("s", true); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_33() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateByte(1, (byte) 123); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_34() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateByte("s", (byte) 123); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_35() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBytes(1, new byte[0]); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_36() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateBytes("s", new byte[0]); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_37() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateCharacterStream(1, (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_38() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateCharacterStream("s", (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_39() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateCharacterStream(1, (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_40() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateCharacterStream("s", (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_41() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateCharacterStream(1, (Reader) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_42() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateCharacterStream("s", (Reader) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_43() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateClob(1, (Clob) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_44() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateClob("s", (Clob) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_45() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateClob(1, (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_46() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateClob("s", (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_47() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateClob(1, (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_48() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateClob("s", (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_49() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateDate(1, (Date) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_50() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateDate("s", (Date) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_51() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateDouble(1, 123d); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_52() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateDouble("s", 123d); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_53() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateFloat(1, 123f); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_54() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateFloat("s", 123f); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_55() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateInt(1, 123); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_56() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateInt("s", 123); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_57() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateLong(1, 123l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_58() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateLong("s", 123l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_59() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNCharacterStream(1, (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_60() throws SQLException { |
| try (ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }")) { |
| rset.updateNCharacterStream("s", (Reader) null); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_61() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNCharacterStream(1, (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_62() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNCharacterStream("s", (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_63() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNCharacterStream(1, (Reader) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_64() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNCharacterStream("s", (Reader) null, 0l); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_65() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNClob(1, (NClob) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_66() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNClob("s", (NClob) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_67() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNClob(1, (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_68() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNClob("s", (Reader) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_69() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNClob(1, (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_70() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNClob("s", (Reader) null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_71() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNull(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_72() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNull("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_73() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateObject(1, null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_74() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateObject("s", null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_75() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateObject(1, null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_76() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateObject("s", null, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_77() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateRef(1, (Ref) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_78() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateRef("s", (Ref) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_79() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateRowId(1, (RowId) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_80() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateRowId("s", (RowId) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_81() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateSQLXML(1, (SQLXML) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_82() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateSQLXML("s", (SQLXML) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_83() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateShort(1, (short) 123); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_84() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateShort("s", (short) 123); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_85() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateString(1, ""); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_86() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateString("s", ""); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_87() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateTime(1, (Time) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_88() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateTime("s", (Time) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_89() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateTimestamp(1, (Timestamp) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_90() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateTimestamp("s", (Timestamp) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_91() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateRow(); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_92() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNString(1, ""); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around trying to update the result set which is not |
| * supported |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_bad_updates_93() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.updateNString("s", ""); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_01() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getArray(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_02() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getArray("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_03() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getAsciiStream(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_04() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getAsciiStream("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @SuppressWarnings("deprecation") |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_05() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBigDecimal(1, 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @SuppressWarnings("deprecation") |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_06() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBigDecimal("s", 0); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_07() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBinaryStream(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_08() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBinaryStream("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_09() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBlob(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_10() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBlob("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_11() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBinaryStream(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_12() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBinaryStream("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_13() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBytes(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_14() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getBytes("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_15() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getCharacterStream(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_16() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getCharacterStream("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_17() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getClob(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_18() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getClob("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_19() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getNCharacterStream(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_20() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getNCharacterStream("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_21() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getNClob(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_22() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getNClob("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_23() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getObject(1, new HashMap<String, Class<?>>()); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_24() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getObject("s", new HashMap<String, Class<?>>()); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_25() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getRef(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_26() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getRef("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_27() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getRowId(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_28() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getRowId("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_29() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getSQLXML(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_30() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getSQLXML("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_31() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getTime(1, (Calendar) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_32() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getTime("s", (Calendar) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_33() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getTimestamp(1, (Calendar) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_34() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getTimestamp("s", (Calendar) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @SuppressWarnings("deprecation") |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_35() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getUnicodeStream(1); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @SuppressWarnings("deprecation") |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_36() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getUnicodeStream("s"); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_37() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getDate(1, (Calendar) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Tests error cases around unsupported getters |
| * |
| * @throws SQLException |
| */ |
| @Test(expected = SQLFeatureNotSupportedException.class) |
| public void results_getters_unsupported_38() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| try { |
| rset.getDate("s", (Calendar) null); |
| } finally { |
| rset.close(); |
| } |
| } |
| |
| /** |
| * Check warnings usage |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_warnings_01() throws SQLException { |
| ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| Assert.assertNull(rset.getWarnings()); |
| |
| rset.close(); |
| } |
| |
| /** |
| * Check warnings usage |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_warnings_02() throws SQLException { |
| JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| Assert.assertNull(rset.getWarnings()); |
| rset.setWarning("Test"); |
| Assert.assertNotNull(rset.getWarnings()); |
| rset.clearWarnings(); |
| Assert.assertNull(rset.getWarnings()); |
| |
| rset.close(); |
| } |
| |
| /** |
| * Check warnings usage |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_warnings_03() throws SQLException { |
| JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| Assert.assertNull(rset.getWarnings()); |
| rset.setWarning("Test", new Exception()); |
| Assert.assertNotNull(rset.getWarnings()); |
| rset.clearWarnings(); |
| Assert.assertNull(rset.getWarnings()); |
| |
| rset.close(); |
| } |
| |
| /** |
| * Check warnings usage |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_warnings_04() throws SQLException { |
| JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| Assert.assertNull(rset.getWarnings()); |
| rset.setWarning(new SQLWarning()); |
| Assert.assertNotNull(rset.getWarnings()); |
| rset.clearWarnings(); |
| Assert.assertNull(rset.getWarnings()); |
| |
| rset.close(); |
| } |
| |
| /** |
| * Check warnings usage |
| * |
| * @throws SQLException |
| */ |
| @Test |
| public void results_warnings_05() throws SQLException { |
| JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }"); |
| |
| Assert.assertNull(rset.getWarnings()); |
| rset.setWarning("A"); |
| Assert.assertNotNull(rset.getWarnings()); |
| rset.setWarning("B"); |
| Assert.assertNotNull(rset.getWarnings()); |
| Assert.assertNotNull(rset.getWarnings().getNextWarning()); |
| rset.clearWarnings(); |
| Assert.assertNull(rset.getWarnings()); |
| |
| rset.close(); |
| } |
| } |