Refine search
/** * @throws Exception If failed. */ @org.junit.Test public void testCloseResultSet0() throws Exception { ResultSet rs0 = stmt.executeQuery(SQL); ResultSet rs1 = stmt.executeQuery(SQL); ResultSet rs2 = stmt.executeQuery(SQL); assert rs0.isClosed() : "ResultSet must be implicitly closed after re-execute statement"; assert rs1.isClosed() : "ResultSet must be implicitly closed after re-execute statement"; assert !rs2.isClosed() : "Last result set must be available"; stmt.close(); assert rs2.isClosed() : "ResultSet must be explicitly closed after close statement"; }
/** * @throws Exception If failed. */ @org.junit.Test public void testClose() throws Exception { String sqlText = "select * from test"; ResultSet rs = stmt.executeQuery(sqlText); assertTrue(rs.next()); assertFalse(rs.isClosed()); assertFalse(stmt.isClosed()); stmt.close(); stmt.close(); // Closing closed is ok assertTrue(stmt.isClosed()); // Current result set must be closed assertTrue(rs.isClosed()); }
/** * Get type info and check the nullable column (regression for an issue * encountered during debugging) * * @throws SQLException */ @Test public void metadata_type_info() throws SQLException { JenaConnection conn = this.getConnection(); DatabaseMetaData metadata = conn.getMetaData(); ResultSet typeInfo = metadata.getTypeInfo(); while (typeInfo.next()) { typeInfo.getShort("NULLABLE"); } Assert.assertTrue(typeInfo.isAfterLast()); typeInfo.close(); Assert.assertTrue(typeInfo.isClosed()); conn.close(); Assert.assertTrue(typeInfo.isClosed()); }
/** * @throws Exception If failed. */ @org.junit.Test public void testCloseOnCompletionBeforeQuery() throws Exception { assert !stmt.isCloseOnCompletion() : "Invalid default closeOnCompletion"; ResultSet rs0 = stmt.executeQuery(SQL); ResultSet rs1 = stmt.executeQuery(SQL); assert rs0.isClosed() : "Result set must be closed implicitly"; assert !stmt.isClosed() : "Statement must not be closed"; rs1.close(); assert !stmt.isClosed() : "Statement must not be closed"; stmt.closeOnCompletion(); ResultSet rs2 = stmt.executeQuery(SQL); assert stmt.isCloseOnCompletion() : "Invalid closeOnCompletion"; rs2.close(); assert stmt.isClosed() : "Statement must be closed"; }
resultSetToCloseOnStmtToClose.next(); final ResultSet resultSetToCloseOnStmtToKeep = plainStmtToKeep.executeQuery("VALUES 'plain Statement query'"); resultSetToCloseOnStmtToKeep.next(); plainStmtToClose.close(); preparedStmtToClose.close(); resultSetToCloseOnStmtToClose.close(); resultSetToCloseOnStmtToKeep.close(); assertTrue("Test setup error", closedPlainStmtOfOpenConn.isClosed()); assertTrue("Test setup error", closedPreparedStmtOfOpenConn.isClosed()); assertTrue("Test setup error", closedResultSetOfClosedStmt.isClosed()); assertTrue("Test setup error", closedResultSetOfOpenStmt.isClosed());
@Test public void testCommonCursorStates() throws SQLException { final ResultSet resultSet = getResultSet(); // right after statement execution, result set is before first row assertTrue(resultSet.isBeforeFirst()); // checking that return values of next and isAfterLast are coherent for (int c = 0; c < 3 && !resultSet.isAfterLast(); ++c) { assertTrue(resultSet.next() != resultSet.isAfterLast()); } // result set is not closed yet, despite fully consumed assertFalse(resultSet.isClosed()); resultSet.close(); // result set is now closed assertTrue(resultSet.isClosed()); // once closed, next should fail thrown.expect(SQLException.class); resultSet.next(); }
/** * @throws Exception If failed. */ @org.junit.Test public void testCloseOnCompletionAfterQuery() throws Exception { assert !stmt.isCloseOnCompletion() : "Invalid default closeOnCompletion"; ResultSet rs0 = stmt.executeQuery(SQL); ResultSet rs1 = stmt.executeQuery(SQL); assert rs0.isClosed() : "Result set must be closed implicitly"; assert !stmt.isClosed() : "Statement must not be closed"; rs1.close(); assert !stmt.isClosed() : "Statement must not be closed"; ResultSet rs2 = stmt.executeQuery(SQL); stmt.closeOnCompletion(); assert stmt.isCloseOnCompletion() : "Invalid closeOnCompletion"; rs2.close(); assert stmt.isClosed() : "Statement must be closed"; }
@Test public void testResultSetIsImplicitlyClosed() throws SQLException { DataSource ds = createDataSourceNoStatementsCache(); ResultSet resultSet; try (Connection connection = ds.getConnection(); Statement statement = connection.createStatement()) { resultSet = statement.executeQuery("select * from actor where first_name = 'CHRISTIAN'"); assertTrue(resultSet.next()); assertFalse(resultSet.isClosed()); assertFalse(resultSet.unwrap(ResultSet.class).isClosed()); } // the statement is closed here assertTrue(resultSet.isClosed()); assertTrue(resultSet.unwrap(ResultSet.class).isClosed()); } }
@Test public void testCommonCursorStates() throws SQLException { final ResultSet resultSet = getResultSet(); // right after statement execution, result set is before first row assertTrue(resultSet.isBeforeFirst()); // checking that return values of next and isAfterLast are coherent for (int c = 0; c < 3 && !resultSet.isAfterLast(); ++c) { assertTrue(resultSet.next() != resultSet.isAfterLast()); } // result set is not closed yet, despite fully consumed assertFalse(resultSet.isClosed()); resultSet.close(); // result set is now closed assertTrue(resultSet.isClosed()); // once closed, next should fail thrown.expect(SQLException.class); resultSet.next(); }
/** * @throws Exception If failed. */ @org.junit.Test public void testCloseResultSetByConnectionClose() throws Exception { ResultSet rs = stmt.executeQuery(SQL); conn.close(); assert stmt.isClosed() : "Statement must be implicitly closed after close connection"; assert rs.isClosed() : "ResultSet must be implicitly closed after close connection"; }
/** * 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()); }
@BeforeClass public static void setUpObjects() throws Exception { // (Note: Can't use JdbcTest's connect(...) for this test class.) connection = connect(); plainStatement = connection.createStatement(); preparedStatement = connection.prepareStatement("VALUES 'PreparedStatement query'"); try { connection.prepareCall("VALUES 'CallableStatement query'"); fail("Test seems to be out of date. Was prepareCall(...) implemented?"); } catch (SQLException | UnsupportedOperationException e) { // Expected. } connection.createArrayOf("INTEGER", new Object[0]); resultSet = plainStatement.executeQuery("VALUES 'plain Statement query'"); resultSet.next(); resultSetMetaData = resultSet.getMetaData(); databaseMetaData = connection.getMetaData(); // Self-check that member variables are set: assertFalse("Test setup error", connection.isClosed()); assertFalse("Test setup error", plainStatement.isClosed()); assertFalse("Test setup error", preparedStatement.isClosed()); assertFalse("Test setup error", resultSet.isClosed()); // (No ResultSetMetaData.isClosed() or DatabaseMetaData.isClosed():) assertNotNull("Test setup error", resultSetMetaData); assertNotNull("Test setup error", databaseMetaData); }
/** * 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()); }