Java 类org.hibernate.util.JDBCExceptionReporter 实例源码

private void execute(boolean script, boolean export, Writer fileOutput, Statement statement, final String sql)
        throws IOException, SQLException {
    String formatted = format( sql );
    if ( delimiter != null ) {
        formatted += delimiter;
    }
    if ( script ) {
        System.out.println( formatted );
    }
    log.debug( formatted );
    if ( outputFile != null ) {
        fileOutput.write( formatted + "\n" );
    }
    if ( export ) {
        statement.executeUpdate( sql );
        SQLWarning warnings = statement.getWarnings();
        if ( warnings != null) {
                JDBCExceptionReporter.logAndClearWarnings( connectionHelper.getConnection() );
        }
    }


}

public void closeConnection(Connection conn) throws HibernateException {
    if ( log.isDebugEnabled() ) {
        log.debug(
                "closing JDBC connection" +
                preparedStatementCountsToString() +
                resultSetCountsToString()
            );
    }

    try {
        if ( !conn.isClosed() ) {
            JDBCExceptionReporter.logAndClearWarnings(conn);
        }
        factory.getConnectionProvider().closeConnection(conn);
    }
    catch (SQLException sqle) {
        throw JDBCExceptionHelper.convert(
                factory.getSQLExceptionConverter(),
                sqle,
                "Cannot close connection"
            );
    }
}

/**
 * Physically closes the JDBC Connection.
 */
private void closeConnection() {
    if ( log.isDebugEnabled() ) {
        log.debug(
                "releasing JDBC connection [" +
                batcher.openResourceStatsAsString() + "]"
            );
    }

    try {
        if ( !connection.isClosed() ) {
            JDBCExceptionReporter.logAndClearWarnings( connection );
        }
        factory.getConnectionProvider().closeConnection( connection );
        connection = null;
    }
    catch (SQLException sqle) {
        throw JDBCExceptionHelper.convert( 
                factory.getSQLExceptionConverter(), 
                sqle, 
                "Cannot release connection"
            );
    }
}

/**
 * This implementation delegates to the underlying DataSource.
 * @see javax.sql.DataSource#getConnection()
 */
@Override
public Connection getConnection() throws SQLException {
    try {
        return this.dataSourceToUse.getConnection();
    }
    catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }
}

/**
 * This implementation calls {@link DataSourceUtils#doCloseConnection},
 * checking against a {@link org.springframework.jdbc.datasource.SmartDataSource}.
 */
@Override
public void closeConnection(Connection con) throws SQLException {
    try {
        DataSourceUtils.doCloseConnection(con, this.dataSourceToUse);
    }
    catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }
}

/**
 * This implementation delegates to the underlying DataSource.
 * @see javax.sql.DataSource#getConnection()
 */
@Override
public Connection getConnection() throws SQLException {
    try {
        return this.dataSourceToUse.getConnection();
    }
    catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }
}

/**
 * This implementation calls {@link DataSourceUtils#doCloseConnection},
 * checking against a {@link org.springframework.jdbc.datasource.SmartDataSource}.
 */
@Override
public void closeConnection(Connection con) throws SQLException {
    try {
        DataSourceUtils.doCloseConnection(con, this.dataSourceToUse);
    }
    catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void closeConnection(Connection con) throws SQLException {
    // simply call Connection.close
    try {
        con.close();
    } catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }

}

public void release() throws SQLException {
    if ( connection != null ) {
        try {
            JDBCExceptionReporter.logAndClearWarnings( connection );
            connectionProvider.closeConnection( connection );
        }
        finally {
            connectionProvider.close();
        }
    }
    connection = null;
}

public void release() throws SQLException {
    // we only release the connection
    if ( connection != null ) {
        JDBCExceptionReporter.logAndClearWarnings( connection );
        if ( toggleAutoCommit ) {
            connection.setAutoCommit( false );
        }
        provider.closeConnection( connection );
        connection = null;
    }
}

public void release() throws SQLException {
    JDBCExceptionReporter.logAndClearWarnings( connection );
    if ( toggleAutoCommit ) {
        connection.setAutoCommit( false );
    }
    connection = null;
}

protected int determineRowCount(int reportedRowCount, PreparedStatement statement) {
    try {
        return toCallableStatement( statement ).getInt( parameterPosition );
    }
    catch( SQLException sqle ) {
        JDBCExceptionReporter.logExceptions( sqle, "could not extract row counts from CallableStatement" );
        throw new GenericJDBCException( "could not extract row counts from CallableStatement", sqle );
    }
}

public void abortBatch(SQLException sqle) {
    try {
        if (batchUpdate!=null) closeStatement(batchUpdate);
    }
    catch (SQLException e) {
        //noncritical, swallow and let the other propagate!
        JDBCExceptionReporter.logExceptions(e);
    }
    finally {
        batchUpdate=null;
        batchUpdateSQL=null;
    }
}

/**
 * This implementation delegates to the underlying DataSource.
 * @see javax.sql.DataSource#getConnection()
 */
public Connection getConnection() throws SQLException {
    try {
        return this.dataSourceToUse.getConnection();
    }
    catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }
}

/**
 * This implementation calls {@link DataSourceUtils#doCloseConnection},
 * checking against a {@link org.springframework.jdbc.datasource.SmartDataSource}.
 */
public void closeConnection(Connection con) throws SQLException {
    try {
        DataSourceUtils.doCloseConnection(con, this.dataSourceToUse);
    }
    catch (SQLException ex) {
        JDBCExceptionReporter.logExceptions(ex);
        throw ex;
    }
}

public void testIntegrityViolation() throws Exception {
    if ( getDialect() instanceof MySQLMyISAMDialect ) {
        reportSkip( "MySQL (ISAM) does not support FK violation checking", "exception conversion" );
        return;
    }

    SQLExceptionConverter converter = getDialect().buildSQLExceptionConverter();

    Session session = openSession();
    session.beginTransaction();
    Connection connection = session.connection();

    // Attempt to insert some bad values into the T_MEMBERSHIP table that should
    // result in a constraint violation
    PreparedStatement ps = null;
    try {
        ps = connection.prepareStatement("INSERT INTO T_MEMBERSHIP (user_id, group_id) VALUES (?, ?)");
        ps.setLong(1, 52134241);    // Non-existent user_id
        ps.setLong(2, 5342);        // Non-existent group_id
        ps.executeUpdate();

        fail("INSERT should have failed");
    }
    catch(SQLException sqle) {
        JDBCExceptionReporter.logExceptions(sqle, "Just output!!!!");
        JDBCException jdbcException = converter.convert(sqle, null, null);
        assertEquals( "Bad conversion [" + sqle.getMessage() + "]", ConstraintViolationException.class , jdbcException.getClass() );
        ConstraintViolationException ex = (ConstraintViolationException) jdbcException;
        System.out.println("Violated constraint name: " + ex.getConstraintName());
    }
    finally {
        if ( ps != null ) {
            try {
                ps.close();
            }
            catch( Throwable ignore ) {
                // ignore...
            }
        }
    }

    session.getTransaction().rollback();
    session.close();
}

/**
 * Converts the given SQLException into Hibernate's JDBCException hierarchy, as well as performing
 * appropriate logging.
 *
 * @param converter    The converter to use.
 * @param sqlException The exception to convert.
 * @param message      An optional error message.
 * @return The converted JDBCException.
 */
public static JDBCException convert(SQLExceptionConverter converter, SQLException sqlException, String message, String sql) {
    JDBCExceptionReporter.logExceptions( sqlException, message + " [" + sql + "]" );
    return converter.convert( sqlException, message, sql );
}