Java Code Examples for java.sql.Connection#clearWarnings()

/**
 * @return a Connection instance that can be used to connect to the
 * given database, if a previously-opened connection is available in
 * the cache. Returns null if none is available in the map.
 */
public synchronized Connection getConnection(String connectStr,
    String username) throws SQLException {
  CacheKey key = new CacheKey(connectStr, username);
  Connection cached = connectionMap.get(key);
  if (null != cached) {
    connectionMap.remove(key);
    if (cached.isReadOnly()) {
      // Read-only mode? Don't want it.
      cached.close();
    }

    if (cached.isClosed()) {
      // This connection isn't usable.
      return null;
    }

    cached.rollback(); // Reset any transaction state.
    cached.clearWarnings();

    LOG.debug("Got cached connection for " + key);
  }

  return cached;
}
 

/**
 * Helper method available to all commands to dump any warnings
 * associated with a connection. The set of warnings is cleared
 * after display.
 * 
 * @param session The session to use for writing
 * @param conn The connection that may, or may not, contain warnings.
 */
static public void printWarnings(Session session, Connection conn) {
    
    try {
        
        SQLWarning w = conn.getWarnings();
        if (w != null) {
            
            printWarnings(session, w);
            conn.clearWarnings();
        }
    }
    catch (SQLException e) {
        
        /* IGNORED */
    }
}
 

/**
 * Calling any Connection method (except isClosed() and close()) on a proxy
 * that was closed by closing the handler should throw an SQLException
 * mentioning the connection was forcibly closed; the owner should not be
 * notified of the exception.
 * 
 * TODO: Consider testing for all Connection methods
 * 
 * @throws SQLException
 */
@Test
public void testClosedHandler_throwsException() throws SQLException {
    final FirebirdConnection physicalConnection = context.mock(FirebirdConnection.class);
    final FBPooledConnection pooled = context.mock(FBPooledConnection.class);
    final PooledConnectionHandler handler = new PooledConnectionHandler(physicalConnection,
            pooled);

    context.checking(new Expectations() {
        {
            connectionHandleReleaseExpectations(this, physicalConnection);
            allowing(pooled).releaseConnectionHandler(handler);
            allowing(pooled).fireConnectionClosed();
            never(pooled).fireConnectionError(with(any(SQLException.class)));
        }
    });

    Connection proxy = handler.getProxy();
    handler.close();

    expectedException.expect(SQLException.class);
    expectedException.expectMessage(PooledConnectionHandler.FORCIBLY_CLOSED_MESSAGE);

    proxy.clearWarnings();
}
 

/**
 * Sakai modification: don't set autocommit, don't rollback if so configured!
 */
public void passivateObject(Object obj) throws Exception
{
	if (obj instanceof Connection)
	{
		Connection conn = (Connection) obj;
		if (m_rollbackOnReturn)
		{
			if (!conn.getAutoCommit() && !conn.isReadOnly())
			{
				Exception e = new RuntimeException("Automatic Transaction Rollback");
				log.error("Transaction RolledBack!", e);
				conn.rollback();
			}
		}

		conn.clearWarnings();
		// conn.setAutoCommit(true);
	}
	if (obj instanceof DelegatingConnection)
	{
		((DelegatingConnection) obj).passivate();
	}
}
 

/**
 * Positive tests for forward only cursors.
 *
 * This method tests forward only cursors.
 *
 *
 * @exception SQLException
 *                Thrown if some unexpected error happens
 */

public void testForwardOnlyPositive() throws SQLException {
    Connection conn = getConnection();
    ResultSet rs;
    Statement s_f_r = createStatement(ResultSet.TYPE_FORWARD_ONLY,
            ResultSet.CONCUR_READ_ONLY);
    // We should have gotten no warnings and a read only forward only cursor
    //JDBC.assertNoWarnings(conn.getWarnings());
    conn.clearWarnings();

    // Verify that setMaxRows(4) succeeds
    s_f_r.setMaxRows(5);
    assertEquals(5, s_f_r.getMaxRows());

    rs = s_f_r.executeQuery("values 1, 2, 3, 4, 5, 6");
    // Iterate straight thru RS, expect only 5 rows.
    JDBC.assertDrainResults(rs, 5);

    s_f_r.close();

}
 

static public void ShowWarnings(PrintStream out, Connection theConnection) {
    try {
	// GET CONNECTION WARNINGS
	SQLWarning warning = null;

	if (theConnection != null) {
		ShowWarnings(out, theConnection.getWarnings());
	}

	if (theConnection != null) {
		theConnection.clearWarnings();
	}
    } catch (SQLException e) {
		ShowSQLException(out, e);
    }
}
 

/**
	Print information about the SQL warnings for the connection
	to the given PrintWriter.
	Walks the list of exceptions, if any.

	@param out the place to write to
	@param theConnection the connection that may have warnings.
 */
static public void ShowWarnings(PrintWriter out, Connection theConnection) {
    try {
	// GET CONNECTION WARNINGS
	SQLWarning warning = null;

	if (theConnection != null) {
		ShowWarnings(out, theConnection.getWarnings());
	}

	if (theConnection != null) {
		theConnection.clearWarnings();
	}
    } catch (SQLException e) {
		ShowSQLException(out, e);
    }
}
 

/**
 * Positive tests for forward only cursors.
 * 
 * This method tests forward only cursors.
 * 
 * 
 * @exception SQLException
 *                Thrown if some unexpected error happens
 */

public void testForwardOnlyPositive() throws SQLException {
    Connection conn = getConnection();
    ResultSet rs;
    Statement s_f_r = createStatement(ResultSet.TYPE_FORWARD_ONLY,
            ResultSet.CONCUR_READ_ONLY);
    // We should have gotten no warnings and a read only forward only cursor
    JDBC.assertNoWarnings(conn.getWarnings());
    conn.clearWarnings();

    // Verify that setMaxRows(4) succeeds
    s_f_r.setMaxRows(5);
    assertEquals(5, s_f_r.getMaxRows());

    rs = s_f_r.executeQuery("values 1, 2, 3, 4, 5, 6");
    // Iterate straight thru RS, expect only 5 rows.
    JDBC.assertDrainResults(rs, 5);
    
    s_f_r.close();

}
 

/**
 * Sakai modification: don't set autocommit, don't rollback if so configured!
 */
public void passivateObject(Object obj) throws Exception
{
	if (obj instanceof Connection)
	{
		Connection conn = (Connection) obj;
		if (m_rollbackOnReturn)
		{
			if (!conn.getAutoCommit() && !conn.isReadOnly())
			{
				Exception e = new RuntimeException("Automatic Transaction Rollback");
				log.error("Transaction RolledBack!", e);
				conn.rollback();
			}
		}

		conn.clearWarnings();
		// conn.setAutoCommit(true);
	}
	if (obj instanceof DelegatingConnection)
	{
		((DelegatingConnection) obj).passivate();
	}
}
 

/**
	Print information about the SQL warnings for the connection
	to the given PrintWriter.
	Walks the list of exceptions, if any.

	@param out the place to write to
	@param theConnection the connection that may have warnings.
 */
static public void ShowWarnings(PrintWriter out, Connection theConnection) {
    try {
	// GET CONNECTION WARNINGS
	SQLWarning warning = null;

	if (theConnection != null) {
		ShowWarnings(out, theConnection.getWarnings());
	}

	if (theConnection != null) {
		theConnection.clearWarnings();
	}
    } catch (SQLException e) {
		ShowSQLException(out, e);
    }
}
 

/**
	Print information about the SQL warnings for the connection
	to the given PrintWriter.
	Walks the list of exceptions, if any.

	@param out the place to write to
	@param theConnection the connection that may have warnings.
 */
static public void ShowWarnings(PrintWriter out, Connection theConnection) {
    try {
	// GET CONNECTION WARNINGS
	SQLWarning warning = null;

	if (theConnection != null) {
		ShowWarnings(out, theConnection.getWarnings());
	}

	if (theConnection != null) {
		theConnection.clearWarnings();
	}
    } catch (SQLException e) {
		ShowSQLException(out, e);
    }
}
 

public void passivateObject(Connection conn) throws Exception
{
    if (!conn.getAutoCommit() && !conn.isReadOnly())
    {
        conn.rollback();
    }
    conn.clearWarnings();
    if (!conn.getAutoCommit())
    {
        conn.setAutoCommit(true);
    }
}
 

/**
 * Calling a Connection method on an open proxy should notify the owner of
 * the occurrence of an exception.
 * 
 * @throws SQLException
 */
@Test
public void testException_Notify() throws SQLException {
    final FirebirdConnection physicalConnection = context.mock(FirebirdConnection.class);
    final FBPooledConnection pooled = context.mock(FBPooledConnection.class);
    final PooledConnectionHandler handler = new PooledConnectionHandler(physicalConnection,
            pooled);
    final Sequence exceptionSequence = context.sequence("exceptionSequence");

    context.checking(new Expectations() {
        {
            SQLException sqle = new FBSQLException("Mock Exception");
            oneOf(physicalConnection).clearWarnings();
            will(throwException(sqle));
            inSequence(exceptionSequence);
            oneOf(pooled).fireConnectionError(sqle);
            inSequence(exceptionSequence);

        }
    });

    Connection proxy = handler.getProxy();

    expectedException.expect(SQLException.class);

    proxy.clearWarnings();
}
 

/**
 * close or reset the connection for reuse
 * @param con
 */
public void close( Connection con ) {
	if ( con != null ) {
		try {
			if ( dsDetails.perRequestConnections || dsDetails.isUnlimitedPool() ) { // reset for reuse within this request
				con.clearWarnings();
				con.setAutoCommit( true );
			} else {
				con.close(); // put back into the connection pool
			}
		} catch ( SQLException ignore ) {}
	}
}
 

@Test
public void testNewInstance() throws SQLException {
    Connection target = Mockito.mock(Connection.class);
    ConnectionPoolCallback callback = Mockito.mock(ConnectionPoolCallback.class);
    Connection proxy = newConnectionProxyFactory().newInstance(target, callback);
    verify(callback, times(1)).acquireConnection();
    verify(callback, never()).releaseConnection(anyLong());
    proxy.clearWarnings();
    proxy.close();
    verify(target, times(1)).clearWarnings();
    verify(callback, times(1)).releaseConnection(anyLong());
    verifyNoMoreInteractions(callback);
}
 

/**
     * Scroll sensitive cursor tests
     *
     * This method tests scroll sensitive cursors. (Not implemented, so we
     * should get back scroll insensitive curors with read only concurrency.)
     *
     * @exception SQLException
     *                Thrown if some unexpected error happens
     */

    public void testScrollSensitive() throws SQLException {
        Connection conn = getConnection();
        ResultSet rs;
        SQLWarning warning;
        Statement s_s_r = null; // sensitive, read only
        Statement s_s_u = null; // sensitive, updatable

        s_s_r = createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_READ_ONLY);

        // We should have gotten a warning and a scroll insensitive cursor
        warning = conn.getWarnings();
        assertNotNull(warning);
        conn.clearWarnings();

        // Verify that result set from statement is
        // scroll insensitive and read only
        rs = s_s_r.executeQuery("select * from t");
        assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rs.getType());
        assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
        rs.close();

        // Close the statement
        s_s_r.close();

        //GemFireXD does not allow scrollable updatable cursors
/*        s_s_u = createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_UPDATABLE);
        // We should have gotten 1 warning and a updatable scroll
        // insensitive cursor.
        warning = conn.getWarnings();
        assertNotNull(warning);
        conn.clearWarnings();

        // Verify that result set from statement is
        // scroll insensitive and read only
        rs = s_s_u.executeQuery("select * from t");
        assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rs.getType());
        assertEquals(ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());

        rs.close();
        */
    }
 

/**
 * CallableStatement tests.
 * 
 * @exception SQLException
 *                Thrown if some unexpected error happens
 */

public void testCallableStatements() throws SQLException {
    Connection conn = getConnection();

    SQLWarning warning;
    CallableStatement cs_s_r = null; // sensitive, read only
    CallableStatement cs_s_u = null; // sensitive, updatable
    CallableStatement cs_i_r = null; // insensitive, read only
    CallableStatement cs_f_r = null; // forward only, read only

    cs_s_r = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);

    // We should have gotten 1 warnings
    warning = conn.getWarnings();
    assertNotNull(warning);
    if (!isDerbyNetClient)
        assertEquals("01J02", warning.getSQLState());
    else
        assertEquals("01J10", warning.getSQLState());

    JDBC.assertNoWarnings(warning.getNextWarning());

    conn.clearWarnings();
    cs_s_r.close();

    cs_s_u = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);

    // We should have gotten 1 warning
    warning = conn.getWarnings();
    assertNotNull(warning);
    if (!isDerbyNetClient)
        assertEquals("01J02", warning.getSQLState());
    else
        assertEquals("01J10", warning.getSQLState());

    JDBC.assertNoWarnings(warning.getNextWarning());
    conn.clearWarnings();
    cs_s_u.close();

    cs_i_r = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

    // We should have gotten 0 warnings
    JDBC.assertNoWarnings(conn.getWarnings());

    conn.clearWarnings();
    cs_i_r.close();

    cs_f_r = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

    // We should have gotten 0 warnings
    JDBC.assertNoWarnings(conn.getWarnings());

    conn.clearWarnings();
    cs_f_r.close();

}
 

/**
     * Scroll sensitive cursor tests
     *
     * This method tests scroll sensitive cursors. (Not implemented, so we
     * should get back scroll insensitive curors with read only concurrency.)
     *
     * @exception SQLException
     *                Thrown if some unexpected error happens
     */

    public void testScrollSensitive() throws SQLException {
        Connection conn = getConnection();
        ResultSet rs;
        SQLWarning warning;
        Statement s_s_r = null; // sensitive, read only
        Statement s_s_u = null; // sensitive, updatable

        s_s_r = createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_READ_ONLY);

        // We should have gotten a warning and a scroll insensitive cursor
        warning = conn.getWarnings();
        assertNotNull(warning);
        conn.clearWarnings();

        // Verify that result set from statement is
        // scroll insensitive and read only
        rs = s_s_r.executeQuery("select * from t");
        assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rs.getType());
        assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
        rs.close();

        // Close the statement
        s_s_r.close();

        //GemFireXD does not allow scrollable updatable cursors
/*        s_s_u = createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_UPDATABLE);
        // We should have gotten 1 warning and a updatable scroll
        // insensitive cursor.
        warning = conn.getWarnings();
        assertNotNull(warning);
        conn.clearWarnings();

        // Verify that result set from statement is
        // scroll insensitive and read only
        rs = s_s_u.executeQuery("select * from t");
        assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rs.getType());
        assertEquals(ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());

        rs.close();
        */
    }
 

/**
 * CallableStatement tests.
 *
 * @exception SQLException
 *                Thrown if some unexpected error happens
 */

public void testCallableStatements() throws SQLException {
    Connection conn = getConnection();

    SQLWarning warning;
    CallableStatement cs_s_r = null; // sensitive, read only
    CallableStatement cs_s_u = null; // sensitive, updatable
    CallableStatement cs_i_r = null; // insensitive, read only
    CallableStatement cs_f_r = null; // forward only, read only

    cs_s_r = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);

    //GemFireXD throws different warnings, not equal to Derby
    /*
    // We should have gotten 1 warnings
    warning = conn.getWarnings();
    assertNotNull(warning);
    if (!isDerbyNetClient)
        assertEquals("01J02", warning.getSQLState());
    else
        assertEquals("01J10", warning.getSQLState());

    //JDBC.assertNoWarnings(warning.getNextWarning());
    
    conn.clearWarnings();
    cs_s_r.close();

    cs_s_u = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);

    // We should have gotten 1 warning
    warning = conn.getWarnings();
    assertNotNull(warning);
    if (!isDerbyNetClient)
        assertEquals("01J02", warning.getSQLState());
    else
        assertEquals("01J10", warning.getSQLState());

    //JDBC.assertNoWarnings(warning.getNextWarning());
    conn.clearWarnings();
    cs_s_u.close();
    */
    cs_i_r = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

    // We should have gotten 0 warnings
    //JDBC.assertNoWarnings(conn.getWarnings());

    conn.clearWarnings();
    cs_i_r.close();

    cs_f_r = prepareCall("values cast (? as Integer)",
            ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

    // We should have gotten 0 warnings
    //JDBC.assertNoWarnings(conn.getWarnings());

    conn.clearWarnings();
    cs_f_r.close();

}
 

/**
 * Scroll sensitive cursor tests
 * 
 * This method tests scroll sensitive cursors. (Not implemented, so we
 * should get back scroll insensitive curors with read only concurrency.)
 * 
 * @exception SQLException
 *                Thrown if some unexpected error happens
 */

public void testScrollSensitive() throws SQLException {
    Connection conn = getConnection();
    ResultSet rs;
    SQLWarning warning;
    Statement s_s_r = null; // sensitive, read only
    Statement s_s_u = null; // sensitive, updatable

    s_s_r = createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
            ResultSet.CONCUR_READ_ONLY);

    // We should have gotten a warning and a scroll insensitive cursor
    warning = conn.getWarnings();
    assertNotNull(warning);
    conn.clearWarnings();

    // Verify that result set from statement is
    // scroll insensitive and read only
    rs = s_s_r.executeQuery("select * from t");
    assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rs.getType());
    assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
    rs.close();

    // Close the statement
    s_s_r.close();

    s_s_u = createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
            ResultSet.CONCUR_UPDATABLE);
    // We should have gotten 1 warning and a updatable scroll
    // insensitive cursor.
    warning = conn.getWarnings();
    assertNotNull(warning);
    conn.clearWarnings();

    // Verify that result set from statement is
    // scroll insensitive and read only
    rs = s_s_u.executeQuery("select * from t");
    assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, rs.getType());
    assertEquals(ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());

    rs.close();
}