Author: steve.ebersole(a)jboss.com
Date: 2007-08-22 11:36:17 -0400 (Wed, 22 Aug 2007)
New Revision: 13948
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainerBuilder.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractProxyHandler.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractResultSetProxyHandler.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/DatabaseMetaDataProxyHandler.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitResultSetProxyHandler.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitStatementProxyHandler.java
Removed:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/DelegateJDBCContainer.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyJDBCContainer.java
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/AbstractStatementDelegate.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/BasicStatementDelegate.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/ConnectionDelegate.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/PreparedStatementDelegate.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxyHandler.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxyHandler.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyBuilder.java
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxyHandler.java
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/batch/TestingServiceImpl.java
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/delegation/TestingServiceImpl.java
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/impl/TestingServiceImpl.java
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/TestingServiceImpl.java
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/PerformanceTest.java
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/TestingServiceImpl.java
Log:
refactoring
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/AbstractStatementDelegate.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/AbstractStatementDelegate.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/AbstractStatementDelegate.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -52,6 +52,10 @@
getJdbcContainer().register( this );
}
+ protected String getSql() {
+ return null;
+ }
+
protected void errorIfInvalid() {
if ( !valid ) {
throw new HibernateException( "statement handle is invalid" );
@@ -99,7 +103,7 @@
return connectionDelegate;
}
- public void close() throws SQLException {
+ public void close() {
if ( valid ) {
LogicalConnectionImplementor lc = connectionDelegate.getLogicalConnection();
getJdbcContainer().release( this );
@@ -109,24 +113,39 @@
// execution-related methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- public ResultSet getGeneratedKeys() throws SQLException {
- return new ResultSetDelegate( this, getWrappedStatement().getGeneratedKeys() );
+ public ResultSet getGeneratedKeys() {
+ try {
+ return new ResultSetDelegate( this, getWrappedStatement().getGeneratedKeys() );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get generated
keys", getSql() );
+ }
}
- public ResultSet getResultSet() throws SQLException {
- currentResultSetDelegate = new ResultSetDelegate( this,
getWrappedStatement().getResultSet() );
- return currentResultSetDelegate;
+ public ResultSet getResultSet() {
+ try {
+ currentResultSetDelegate = new ResultSetDelegate( this,
getWrappedStatement().getResultSet() );
+ return currentResultSetDelegate;
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get result
set", getSql() );
+ }
}
- public int getUpdateCount() throws SQLException {
- return getWrappedStatement().getUpdateCount();
+ public int getUpdateCount() {
+ try {
+ return getWrappedStatement().getUpdateCount();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get update
count", getSql() );
+ }
}
- public boolean getMoreResults() throws SQLException {
+ public boolean getMoreResults() {
return getMoreResults( Statement.CLOSE_CURRENT_RESULT );
}
- public boolean getMoreResults(int current) throws SQLException {
+ public boolean getMoreResults(int current) {
if ( current == Statement.CLOSE_ALL_RESULTS ) {
log.warn( "getMoreResults call requested all previous results be closed, but
thats not possible here" );
current = Statement.CLOSE_CURRENT_RESULT;
@@ -135,89 +154,195 @@
getJdbcContainer().release( currentResultSetDelegate );
}
currentResultSetDelegate = null;
- return getWrappedStatement().getMoreResults( current );
+
+ try {
+ return getWrappedStatement().getMoreResults( current );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
getMoreResults", getSql() );
+ }
}
- public void cancel() throws SQLException {
- getWrappedStatement().cancel();
+ public void cancel() {
+ try {
+ getWrappedStatement().cancel();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to cancel",
getSql() );
+ }
}
- public void clearBatch() throws SQLException {
- getWrappedStatement().clearBatch();
+ public void clearBatch() {
+ try {
+ getWrappedStatement().clearBatch();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to clear
batch", getSql() );
+ }
}
- public int[] executeBatch() throws SQLException {
- return getWrappedStatement().executeBatch();
+ public int[] executeBatch() {
+ try {
+ return getWrappedStatement().executeBatch();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
batch", getSql() );
+ }
}
// general Statement methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- public int getMaxFieldSize() throws SQLException {
- return getWrappedStatement().getMaxFieldSize();
+ public int getMaxFieldSize() {
+ try {
+ return getWrappedStatement().getMaxFieldSize();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get max field
size", getSql() );
+ }
}
- public void setMaxFieldSize(int max) throws SQLException {
- getWrappedStatement().setMaxFieldSize( max );
+ public void setMaxFieldSize(int max) {
+ try {
+ getWrappedStatement().setMaxFieldSize( max );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set max field
size", getSql() );
+ }
}
- public int getMaxRows() throws SQLException {
- return getWrappedStatement().getMaxRows();
+ public int getMaxRows() {
+ try {
+ return getWrappedStatement().getMaxRows();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get max
rows", getSql() );
+ }
}
- public void setMaxRows(int max) throws SQLException {
- getWrappedStatement().setMaxRows( max );
+ public void setMaxRows(int max) {
+ try {
+ getWrappedStatement().setMaxRows( max );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set max
rows", getSql() );
+ }
}
- public void setEscapeProcessing(boolean enable) throws SQLException {
- getWrappedStatement().setEscapeProcessing( enable );
+ public void setEscapeProcessing(boolean enable) {
+ try {
+ getWrappedStatement().setEscapeProcessing( enable );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set escape
processing", getSql() );
+ }
}
- public int getQueryTimeout() throws SQLException {
- return getWrappedStatement().getQueryTimeout();
+ public int getQueryTimeout() {
+ try {
+ return getWrappedStatement().getQueryTimeout();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get query
timeout", getSql() );
+ }
}
- public void setQueryTimeout(int seconds) throws SQLException {
- getWrappedStatement().setQueryTimeout( seconds );
+ public void setQueryTimeout(int seconds) {
+ try {
+ getWrappedStatement().setQueryTimeout( seconds );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set query
timeout", getSql() );
+ }
}
- public void setCursorName(String name) throws SQLException {
- getWrappedStatement().setCursorName( name );
+ public void setCursorName(String name) {
+ try {
+ getWrappedStatement().setCursorName( name );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set cursor
name", getSql() );
+ }
}
- public void setFetchDirection(int direction) throws SQLException {
- getWrappedStatement().setFetchDirection( direction );
+ public int getFetchDirection() {
+ try {
+ return getWrappedStatement().getFetchDirection();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get fetch
direction", getSql() );
+ }
}
- public int getFetchDirection() throws SQLException {
- return getWrappedStatement().getFetchDirection();
+ public void setFetchDirection(int direction) {
+ try {
+ getWrappedStatement().setFetchDirection( direction );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set fetch
direction", getSql() );
+ }
}
- public void setFetchSize(int rows) throws SQLException {
- getWrappedStatement().setFetchSize( rows );
+ public int getFetchSize() {
+ try {
+ return getWrappedStatement().getFetchSize();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get fetch
size", getSql() );
+ }
}
- public int getFetchSize() throws SQLException {
- return getWrappedStatement().getFetchSize();
+ public void setFetchSize(int rows) {
+ try {
+ getWrappedStatement().setFetchSize( rows );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set fetch
size", getSql() );
+ }
}
- public int getResultSetConcurrency() throws SQLException {
- return getWrappedStatement().getResultSetConcurrency();
+ public int getResultSetConcurrency() {
+ try {
+ return getWrappedStatement().getResultSetConcurrency();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get result
set concurrency", getSql() );
+ }
}
- public int getResultSetType() throws SQLException {
- return getWrappedStatement().getResultSetType();
+ public int getResultSetType() {
+ try {
+ return getWrappedStatement().getResultSetType();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get result
set type", getSql() );
+ }
}
- public int getResultSetHoldability() throws SQLException {
- return getWrappedStatement().getResultSetHoldability();
+ public int getResultSetHoldability() {
+ try {
+ return getWrappedStatement().getResultSetHoldability();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get result
set holdability", getSql() );
+ }
}
- public SQLWarning getWarnings() throws SQLException {
- return getWrappedStatement().getWarnings();
+ public SQLWarning getWarnings() {
+ try {
+ return getWrappedStatement().getWarnings();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
warnings", getSql() );
+ }
}
- public void clearWarnings() throws SQLException {
- getWrappedStatement().clearWarnings();
+ public void clearWarnings() {
+ try {
+ getWrappedStatement().clearWarnings();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to clear
warnings", getSql() );
+ }
}
}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/BasicStatementDelegate.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/BasicStatementDelegate.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/BasicStatementDelegate.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -29,53 +29,103 @@
super( connectionDelegate, statement );
}
- public void addBatch(String sql) throws SQLException {
+ public void addBatch(String sql) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- getWrappedStatement().addBatch( sql );
+ try {
+ getWrappedStatement().addBatch( sql );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to add
batch", sql );
+ }
}
- public boolean execute(String sql) throws SQLException {
+ public boolean execute(String sql) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().execute( sql );
+ try {
+ return getWrappedStatement().execute( sql );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
execute", sql );
+ }
}
- public ResultSet executeQuery(String sql) throws SQLException {
+ public ResultSet executeQuery(String sql) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return new ResultSetDelegate( this, getWrappedStatement().executeQuery( sql ) );
+ try {
+ return new ResultSetDelegate( this, getWrappedStatement().executeQuery( sql ) );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
query", sql );
+ }
}
- public int executeUpdate(String sql) throws SQLException {
+ public int executeUpdate(String sql) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().executeUpdate( sql );
+ try {
+ return getWrappedStatement().executeUpdate( sql );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
update", sql );
+ }
}
- public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
+ public int executeUpdate(String sql, int autoGeneratedKeys) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().executeUpdate( sql, autoGeneratedKeys );
+ try {
+ return getWrappedStatement().executeUpdate( sql, autoGeneratedKeys );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
update", sql );
+ }
}
- public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
+ public int executeUpdate(String sql, int[] columnIndexes) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().executeUpdate( sql, columnIndexes );
+ try {
+ return getWrappedStatement().executeUpdate( sql, columnIndexes );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
update", sql );
+ }
}
- public int executeUpdate(String sql, String[] columnNames) throws SQLException {
+ public int executeUpdate(String sql, String[] columnNames) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().executeUpdate( sql, columnNames );
+ try {
+ return getWrappedStatement().executeUpdate( sql, columnNames );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
update", sql );
+ }
}
- public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
+ public boolean execute(String sql, int autoGeneratedKeys) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().execute( sql, autoGeneratedKeys );
+ try {
+ return getWrappedStatement().execute( sql, autoGeneratedKeys );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
execute", sql );
+ }
}
- public boolean execute(String sql, int[] columnIndexes) throws SQLException {
+ public boolean execute(String sql, int[] columnIndexes) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().execute( sql, columnIndexes );
+ try {
+ return getWrappedStatement().execute( sql, columnIndexes );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
execute", sql );
+ }
}
- public boolean execute(String sql, String[] columnNames) throws SQLException {
+ public boolean execute(String sql, String[] columnNames) {
getJdbcServices().getSqlStatementLogger().logStatement( sql );
- return getWrappedStatement().execute( sql, columnNames );
+ try {
+ return getWrappedStatement().execute( sql, columnNames );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
execute", sql );
+ }
}
}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/ConnectionDelegate.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/ConnectionDelegate.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/ConnectionDelegate.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -293,91 +293,202 @@
return !valid;
}
- public void setAutoCommit(boolean autoCommit) throws SQLException {
- getWrappedConnection().setAutoCommit( autoCommit );
+ public void setAutoCommit(boolean autoCommit) {
+ try {
+ getWrappedConnection().setAutoCommit( autoCommit );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
auto-commit" );
+ }
}
- public boolean getAutoCommit() throws SQLException {
- return getWrappedConnection().getAutoCommit();
+ public boolean getAutoCommit() {
+ try {
+ return getWrappedConnection().getAutoCommit();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
auto-commit" );
+ }
}
- public void commit() throws SQLException {
- getWrappedConnection().commit();
+ public void commit() {
+ try {
+ getWrappedConnection().commit();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to commit"
);
+ }
}
- public void rollback() throws SQLException {
- getWrappedConnection().rollback();
+ public void rollback() {
+ try {
+ getWrappedConnection().rollback();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
rollback" );
+ }
}
- public DatabaseMetaData getMetaData() throws SQLException {
- return getWrappedConnection().getMetaData();
+ public DatabaseMetaData getMetaData() {
+ // todo : wrap...
+ try {
+ return getWrappedConnection().getMetaData();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
metadata" );
+ }
}
- public String nativeSQL(String sql) throws SQLException {
- return getWrappedConnection().nativeSQL( sql );
+ public String nativeSQL(String sql) {
+ try {
+ return getWrappedConnection().nativeSQL( sql );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to native-ize
sql" );
+ }
}
- public void setReadOnly(boolean readOnly) throws SQLException {
- getWrappedConnection().setReadOnly( readOnly );
+ public void setReadOnly(boolean readOnly) {
+ try {
+ getWrappedConnection().setReadOnly( readOnly );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
readonly-ness" );
+ }
}
- public boolean isReadOnly() throws SQLException {
- return getWrappedConnection().isReadOnly();
+ public boolean isReadOnly() {
+ try {
+ return getWrappedConnection().isReadOnly();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to query
readonly-ness" );
+ }
}
- public void setCatalog(String catalog) throws SQLException {
- getWrappedConnection().setCatalog( catalog );
+ public void setCatalog(String catalog) {
+ try {
+ getWrappedConnection().setCatalog( catalog );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
catalog" );
+ }
}
- public String getCatalog() throws SQLException {
- return getWrappedConnection().getCatalog();
+ public String getCatalog() {
+ try {
+ return getWrappedConnection().getCatalog();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
auto-commit" );
+ }
}
- public void setTransactionIsolation(int level) throws SQLException {
- getWrappedConnection().setTransactionIsolation( level );
+ public void setTransactionIsolation(int level) {
+ try {
+ getWrappedConnection().setTransactionIsolation( level );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
isolation" );
+ }
}
- public int getTransactionIsolation() throws SQLException {
- return getWrappedConnection().getTransactionIsolation();
+ public int getTransactionIsolation() {
+ try {
+ return getWrappedConnection().getTransactionIsolation();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
isolation" );
+ }
}
- public SQLWarning getWarnings() throws SQLException {
- return getWrappedConnection().getWarnings();
+ public SQLWarning getWarnings() {
+ try {
+ return getWrappedConnection().getWarnings();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
wranings" );
+ }
}
- public void clearWarnings() throws SQLException {
- getWrappedConnection().clearWarnings();
+ public void clearWarnings() {
+ try {
+ getWrappedConnection().clearWarnings();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to clear
warnings" );
+ }
}
- public Map<String, Class<?>> getTypeMap() throws SQLException {
- return getWrappedConnection().getTypeMap();
+ public Map<String, Class<?>> getTypeMap() {
+ try {
+ return getWrappedConnection().getTypeMap();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
type-map" );
+ }
}
- public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
- getWrappedConnection().setTypeMap( map );
+ public void setTypeMap(Map<String, Class<?>> map) {
+ try {
+ getWrappedConnection().setTypeMap( map );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
type-map" );
+ }
}
- public void setHoldability(int holdability) throws SQLException {
- getWrappedConnection().setHoldability( holdability );
+ public void setHoldability(int holdability) {
+ try {
+ getWrappedConnection().setHoldability( holdability );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
holdability" );
+ }
}
- public int getHoldability() throws SQLException {
- return getWrappedConnection().getHoldability();
+ public int getHoldability() {
+ try {
+ return getWrappedConnection().getHoldability();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get
holdability" );
+ }
}
- public Savepoint setSavepoint() throws SQLException {
- return getWrappedConnection().setSavepoint();
+ public Savepoint setSavepoint() {
+ try {
+ return getWrappedConnection().setSavepoint();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
savepoint" );
+ }
}
- public Savepoint setSavepoint(String name) throws SQLException {
- return getWrappedConnection().setSavepoint( name );
+ public Savepoint setSavepoint(String name) {
+ try {
+ return getWrappedConnection().setSavepoint( name );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to set
savepoint" );
+ }
}
- public void rollback(Savepoint savepoint) throws SQLException {
- getWrappedConnection().rollback( savepoint );
+ public void rollback(Savepoint savepoint) {
+ try {
+ getWrappedConnection().rollback( savepoint );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to rollback
savepoint" );
+ }
}
- public void releaseSavepoint(Savepoint savepoint) throws SQLException {
- getWrappedConnection().releaseSavepoint( savepoint );
+ public void releaseSavepoint(Savepoint savepoint) {
+ try {
+ getWrappedConnection().releaseSavepoint( savepoint );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to release
savepoint" );
+ }
}
}
Deleted:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/DelegateJDBCContainer.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/DelegateJDBCContainer.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/DelegateJDBCContainer.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
- *
- * This copyrighted material is made available to anyone wishing to use, modify,
- * copy, or redistribute it subject to the terms and conditions of the GNU
- * Lesser General Public License, v. 2.1. This program is distributed in the
- * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details. You should have received a
- * copy of the GNU Lesser General Public License, v.2.1 along with this
- * distribution; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Red Hat Author(s): Steve Ebersole
- */
-package org.hibernate.jdbc.delegation;
-
-import java.sql.ResultSet;
-import java.sql.Statement;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import org.hibernate.jdbc.impl.BasicJDBCContainer;
-import org.hibernate.jdbc.impl.StatementWrapperImplementor;
-import org.hibernate.jdbc.impl.ResultSetWrapperImplementor;
-import org.hibernate.jdbc.util.ExceptionHelper;
-
-/**
- * DelegateJDBCContainer implementation
- *
- * @author Steve Ebersole
- */
-public class DelegateJDBCContainer extends BasicJDBCContainer {
- private static final Logger log = LoggerFactory.getLogger( DelegateJDBCContainer.class
);
-
- public DelegateJDBCContainer(ExceptionHelper exceptionHelper) {
- super( exceptionHelper );
- }
-
- protected void close(Statement statement) {
- if ( statement instanceof StatementWrapperImplementor ) {
- StatementWrapperImplementor wrapper = ( StatementWrapperImplementor ) statement;
- super.close( wrapper.getWrappedStatement() );
- wrapper.invalidate();
- }
- else {
- super.close( statement );
- }
- }
-
- protected void close(ResultSet resultSet) {
- if ( resultSet instanceof ResultSetWrapperImplementor ) {
- ResultSetWrapperImplementor wrapper = ( ResultSetWrapperImplementor ) resultSet;
- super.close( wrapper.getWrappedResultSet() );
- wrapper.invalidate();
- }
- else {
- super.close( resultSet );
- }
- }
-}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/PreparedStatementDelegate.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/PreparedStatementDelegate.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/delegation/PreparedStatementDelegate.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -53,6 +53,10 @@
getJdbcServices().getSqlStatementLogger().logStatement( sql );
}
+ protected String getSql() {
+ return sql;
+ }
+
private PreparedStatement getPreparedStatement() {
return ( PreparedStatement ) super.getWrappedStatement();
}
@@ -60,153 +64,338 @@
// PreparedStatement impl
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- public void addBatch() throws SQLException {
- getPreparedStatement().addBatch();
+ public void addBatch() {
+ try {
+ getPreparedStatement().addBatch();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
addBatch", sql );
+ }
}
- public boolean execute() throws SQLException {
- return getPreparedStatement().execute();
+ public boolean execute() {
+ try {
+ return getPreparedStatement().execute();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
execute", sql );
+ }
}
- public ResultSet executeQuery() throws SQLException {
- return new ResultSetDelegate( this, getPreparedStatement().executeQuery() );
+ public ResultSet executeQuery() {
+ try {
+ return new ResultSetDelegate( this, getPreparedStatement().executeQuery() );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
query", sql );
+ }
}
- public int executeUpdate() throws SQLException {
- return getPreparedStatement().executeUpdate();
+ public int executeUpdate() {
+ try {
+ return getPreparedStatement().executeUpdate();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to execute
update", sql );
+ }
}
- public ResultSetMetaData getMetaData() throws SQLException {
- return getPreparedStatement().getMetaData();
+ public ResultSetMetaData getMetaData() {
+ try {
+ return getPreparedStatement().getMetaData();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get result
set metadata", sql );
+ }
}
- public ParameterMetaData getParameterMetaData() throws SQLException {
- return getPreparedStatement().getParameterMetaData();
+ public ParameterMetaData getParameterMetaData() {
+ try {
+ return getPreparedStatement().getParameterMetaData();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to get parameter
metadata", sql );
+ }
}
- public void clearParameters() throws SQLException {
- getPreparedStatement().clearParameters();
+ public void clearParameters() {
+ try {
+ getPreparedStatement().clearParameters();
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to clear
parameters", sql );
+ }
}
- public void setNull(int parameterIndex, int sqlType) throws SQLException {
- getPreparedStatement().setNull( parameterIndex, sqlType );
+ public void setNull(int parameterIndex, int sqlType) {
+ try {
+ getPreparedStatement().setNull( parameterIndex, sqlType );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setNull", sql );
+ }
}
- public void setBoolean(int parameterIndex, boolean x) throws SQLException {
- getPreparedStatement().setBoolean( parameterIndex, x );
+ public void setNull(int parameterIndex, int sqlType, String typeName) {
+ try {
+ getPreparedStatement().setNull( parameterIndex, sqlType, typeName );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setNull", sql );
+ }
}
- public void setByte(int parameterIndex, byte x) throws SQLException {
- getPreparedStatement().setByte( parameterIndex, x );
+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) {
+ try {
+ getPreparedStatement().setObject( parameterIndex, x, targetSqlType, scale );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setObject", sql );
+ }
}
- public void setShort(int parameterIndex, short x) throws SQLException {
- getPreparedStatement().setShort( parameterIndex, x );
+ public void setObject(int parameterIndex, Object x, int targetSqlType) {
+ try {
+ getPreparedStatement().setObject( parameterIndex, x, targetSqlType );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setObject", sql );
+ }
}
- public void setInt(int parameterIndex, int x) throws SQLException {
- getPreparedStatement().setInt( parameterIndex, x );
+ public void setObject(int parameterIndex, Object x) {
+ try {
+ getPreparedStatement().setObject( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setObject", sql );
+ }
}
- public void setLong(int parameterIndex, long x) throws SQLException {
- getPreparedStatement().setLong( parameterIndex, x );
+ public void setBoolean(int parameterIndex, boolean x) {
+ try {
+ getPreparedStatement().setBoolean( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setBoolean", sql );
+ }
}
- public void setFloat(int parameterIndex, float x) throws SQLException {
- getPreparedStatement().setFloat( parameterIndex, x );
+ public void setByte(int parameterIndex, byte x) {
+ try {
+ getPreparedStatement().setByte( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setByte", sql );
+ }
}
- public void setDouble(int parameterIndex, double x) throws SQLException {
- getPreparedStatement().setDouble( parameterIndex, x );
+ public void setShort(int parameterIndex, short x) {
+ try {
+ getPreparedStatement().setShort( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setShort", sql );
+ }
}
- public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
- getPreparedStatement().setBigDecimal( parameterIndex, x );
+ public void setInt(int parameterIndex, int x) {
+ try {
+ getPreparedStatement().setInt( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to setInt",
sql );
+ }
}
- public void setString(int parameterIndex, String x) throws SQLException {
- getPreparedStatement().setString( parameterIndex, x );
+ public void setLong(int parameterIndex, long x) {
+ try {
+ getPreparedStatement().setLong( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setLong", sql );
+ }
}
- public void setBytes(int parameterIndex, byte[] x) throws SQLException {
- getPreparedStatement().setBytes( parameterIndex, x );
+ public void setFloat(int parameterIndex, float x) {
+ try {
+ getPreparedStatement().setFloat( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setFloat", sql );
+ }
}
- public void setDate(int parameterIndex, Date x) throws SQLException {
- getPreparedStatement().setDate( parameterIndex, x );
+ public void setDouble(int parameterIndex, double x) {
+ try {
+ getPreparedStatement().setDouble( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setDouble", sql );
+ }
}
- public void setTime(int parameterIndex, Time x) throws SQLException {
- getPreparedStatement().setTime( parameterIndex, x );
+ public void setBigDecimal(int parameterIndex, BigDecimal x) {
+ try {
+ getPreparedStatement().setBigDecimal( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setBigDecimal", sql );
+ }
}
- public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
- getPreparedStatement().setTimestamp( parameterIndex, x );
+ public void setString(int parameterIndex, String x) {
+ try {
+ getPreparedStatement().setString( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setString", sql );
+ }
}
- public void setAsciiStream(int parameterIndex, InputStream x, int length) throws
SQLException {
- getPreparedStatement().setAsciiStream( parameterIndex, x, length );
+ public void setBytes(int parameterIndex, byte[] x) {
+ try {
+ getPreparedStatement().setBytes( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setBytes", sql );
+ }
}
- @Deprecated
- public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws
SQLException {
- getPreparedStatement().setUnicodeStream( parameterIndex, x, length );
+ public void setDate(int parameterIndex, Date x) {
+ try {
+ getPreparedStatement().setDate( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setDate", sql );
+ }
}
- public void setBinaryStream(int parameterIndex, InputStream x, int length) throws
SQLException {
- getPreparedStatement().setBinaryStream( parameterIndex, x, length );
+ public void setTime(int parameterIndex, Time x) {
+ try {
+ getPreparedStatement().setTime( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setTime", sql );
+ }
}
- public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws
SQLException {
- getPreparedStatement().setObject( parameterIndex, x, targetSqlType, scale );
+ public void setTimestamp(int parameterIndex, Timestamp x) {
+ try {
+ getPreparedStatement().setTimestamp( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setTimestamp", sql );
+ }
}
- public void setObject(int parameterIndex, Object x, int targetSqlType) throws
SQLException {
- getPreparedStatement().setObject( parameterIndex, x, targetSqlType );
+ public void setAsciiStream(int parameterIndex, InputStream x, int length) {
+ try {
+ getPreparedStatement().setAsciiStream( parameterIndex, x, length );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setAsciiStream", sql );
+ }
}
- public void setObject(int parameterIndex, Object x) throws SQLException {
- getPreparedStatement().setObject( parameterIndex, x );
+ @Deprecated
+ public void setUnicodeStream(int parameterIndex, InputStream x, int length) {
+ try {
+ getPreparedStatement().setUnicodeStream( parameterIndex, x, length );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setUnicodeStream", sql );
+ }
}
- public void setCharacterStream(int parameterIndex, Reader reader, int length) throws
SQLException {
- getPreparedStatement().setCharacterStream( parameterIndex, reader, length );
+ public void setBinaryStream(int parameterIndex, InputStream x, int length) {
+ try {
+ getPreparedStatement().setBinaryStream( parameterIndex, x, length );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setBinaryStream", sql );
+ }
}
- public void setRef(int parameterIndex, Ref x) throws SQLException {
- getPreparedStatement().setRef( parameterIndex, x );
+ public void setCharacterStream(int parameterIndex, Reader reader, int length) {
+ try {
+ getPreparedStatement().setCharacterStream( parameterIndex, reader, length );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setCharacterStream", sql );
+ }
}
- public void setBlob(int parameterIndex, Blob x) throws SQLException {
- getPreparedStatement().setBlob( parameterIndex, x );
+ public void setRef(int parameterIndex, Ref x) {
+ try {
+ getPreparedStatement().setRef( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to setRef",
sql );
+ }
}
- public void setClob(int parameterIndex, Clob x) throws SQLException {
- getPreparedStatement().setClob( parameterIndex, x );
+ public void setBlob(int parameterIndex, Blob x) {
+ try {
+ getPreparedStatement().setBlob( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setBlob", sql );
+ }
}
- public void setArray(int parameterIndex, Array x) throws SQLException {
- getPreparedStatement().setArray( parameterIndex, x );
+ public void setClob(int parameterIndex, Clob x) {
+ try {
+ getPreparedStatement().setClob( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setClob", sql );
+ }
}
- public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
- getPreparedStatement().setDate( parameterIndex, x, cal );
+ public void setArray(int parameterIndex, Array x) {
+ try {
+ getPreparedStatement().setArray( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setArray", sql );
+ }
}
- public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
- getPreparedStatement().setTime( parameterIndex, x, cal );
+ public void setDate(int parameterIndex, Date x, Calendar cal) {
+ try {
+ getPreparedStatement().setDate( parameterIndex, x, cal );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setDate", sql );
+ }
}
- public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws
SQLException {
- getPreparedStatement().setTimestamp( parameterIndex, x, cal );
+ public void setTime(int parameterIndex, Time x, Calendar cal) {
+ try {
+ getPreparedStatement().setTime( parameterIndex, x, cal );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setTime", sql );
+ }
}
- public void setNull(int parameterIndex, int sqlType, String typeName) throws
SQLException {
- getPreparedStatement().setNull( parameterIndex, sqlType, typeName );
+ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) {
+ try {
+ getPreparedStatement().setTimestamp( parameterIndex, x, cal );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to
setTimestamp", sql );
+ }
}
- public void setURL(int parameterIndex, URL x) throws SQLException {
- getPreparedStatement().setURL( parameterIndex, x );
+ public void setURL(int parameterIndex, URL x) {
+ try {
+ getPreparedStatement().setURL( parameterIndex, x );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, "unable to setURL",
sql );
+ }
}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainer.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -103,6 +103,9 @@
Set resultSets = ( Set ) xref.get( statement );
if ( resultSets != null ) {
resultSets.remove( resultSet );
+ if ( resultSets.isEmpty() ) {
+ xref.remove( statement );
+ }
}
close( resultSet );
}
@@ -141,6 +144,14 @@
protected void close(Statement statement) {
log.trace( "closing prepared statement [{}]", statement );
+
+ if ( statement instanceof StatementWrapperImplementor ) {
+ StatementWrapperImplementor wrapper = ( StatementWrapperImplementor ) statement;
+ close( wrapper.getWrappedStatement() );
+ wrapper.invalidate();
+ return;
+ }
+
try {
// if we are unable to "clean" the prepared statement,
// we do not close it
@@ -166,6 +177,13 @@
protected void close(ResultSet resultSet) {
log.trace( "closing result set [{}]", resultSet );
+
+ if ( resultSet instanceof ResultSetWrapperImplementor ) {
+ ResultSetWrapperImplementor wrapper = ( ResultSetWrapperImplementor ) resultSet;
+ close( wrapper.getWrappedResultSet() );
+ wrapper.invalidate();
+ }
+
try {
resultSet.close();
}
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainerBuilder.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainerBuilder.java
(rev 0)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/impl/BasicJDBCContainerBuilder.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.impl;
+
+import org.hibernate.jdbc.JDBCContainerBuilder;
+import org.hibernate.jdbc.JDBCContainer;
+import org.hibernate.jdbc.util.ExceptionHelper;
+
+/**
+ * BasicJDBCContainerBuilder implementation
+ *
+ * @author Steve Ebersole
+ */
+public class BasicJDBCContainerBuilder implements JDBCContainerBuilder {
+ private final ExceptionHelper exceptionHelper;
+
+ public BasicJDBCContainerBuilder(ExceptionHelper exceptionHelper) {
+ this.exceptionHelper = exceptionHelper;
+ }
+
+ public JDBCContainer buildJdbcContainer() {
+ return new BasicJDBCContainer( exceptionHelper );
+ }
+}
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractProxyHandler.java
(rev 0)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+import org.hibernate.HibernateException;
+
+/**
+ * Basic support for
+ *
+ * @author Steve Ebersole
+ */
+public abstract class AbstractProxyHandler implements InvocationHandler {
+ private boolean valid = true;
+ private final int hashCode;
+
+ public AbstractProxyHandler(int hashCode) {
+ this.hashCode = hashCode;
+ }
+
+ protected abstract Object continueInvocation(Object proxy, Method method, Object[] args)
throws Throwable;
+
+ public String toString() {
+ return super.toString() + "[valid=" + valid + "]";
+ }
+
+ public final int hashCode() {
+ return hashCode;
+ }
+
+ protected final boolean isValid() {
+ return valid;
+ }
+
+ protected final void invalidate() {
+ valid = false;
+ }
+
+ protected final void errorIfInvalid() {
+ if ( !isValid() ) {
+ throw new HibernateException( "proxy handle is no longer valid" );
+ }
+ }
+
+ public final Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
+ String methodName = method.getName();
+
+ // basic Object methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ if ( "toString".equals( methodName ) ) {
+ return this.toString();
+ }
+ if ( "hashCode".equals( methodName ) ) {
+ return this.hashCode();
+ }
+ if ( "equals".equals( methodName ) ) {
+ return this.equals( args[0] );
+ }
+
+ return continueInvocation( proxy, method, args );
+ }
+
+}
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractResultSetProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractResultSetProxyHandler.java
(rev 0)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractResultSetProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.HibernateException;
+import org.hibernate.jdbc.JDBCContainer;
+import org.hibernate.jdbc.JDBCServices;
+
+/**
+ * AbstractResultSetProxyHandler implementation
+ *
+ * @author Steve Ebersole
+ */
+public abstract class AbstractResultSetProxyHandler extends AbstractProxyHandler {
+ private static final Logger log = LoggerFactory.getLogger(
AbstractResultSetProxyHandler.class );
+
+ private ResultSet resultSet;
+
+ public AbstractResultSetProxyHandler(ResultSet resultSet) {
+ super( resultSet.hashCode() );
+ this.resultSet = resultSet;
+ }
+
+ protected abstract JDBCServices getJdbcServices();
+
+ protected abstract JDBCContainer getJdbcContainer();
+
+ protected abstract Statement getExposeableStatement();
+
+ protected final ResultSet getResultSet() {
+ errorIfInvalid();
+ return resultSet;
+ }
+
+ protected final ResultSet getResultSetWithoutChecks() {
+ return resultSet;
+ }
+
+ protected Object continueInvocation(Object proxy, Method method, Object[] args) throws
Throwable {
+ String methodName = method.getName();
+ log.trace( "Handling invocation of resultset method [{}]", methodName );
+
+ // other methods allowed while invalid
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ if ( "close".equals( methodName ) ) {
+ explicitClose( ( ResultSet ) proxy );
+ return null;
+ }
+ if ( "invalidate".equals( methodName ) ) {
+ invalidateHandle();
+ return null;
+ }
+
+ errorIfInvalid();
+
+ if ( "getWrappedResultSet".equals( methodName ) ) {
+ return getResultSetWithoutChecks();
+ }
+
+ if ( "getStatement".equals( methodName ) ) {
+ return getExposeableStatement();
+ }
+
+ try {
+ return method.invoke( resultSet, args );
+ }
+ catch ( InvocationTargetException e ) {
+ Throwable realException = e.getTargetException();
+ if ( SQLException.class.isInstance( realException ) ) {
+ throw getJdbcServices().getExceptionHelper()
+ .convert( ( SQLException ) realException, realException.getMessage() );
+ }
+ else {
+ throw realException;
+ }
+ }
+ }
+
+ private void explicitClose(ResultSet proxy) {
+ if ( isValid() ) {
+ getJdbcContainer().release( proxy );
+ }
+ }
+
+ protected void invalidateHandle() {
+ resultSet = null;
+ invalidate();
+ }
+}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxyHandler.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/AbstractStatementProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -15,7 +15,6 @@
*/
package org.hibernate.jdbc.proxy;
-import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
@@ -26,7 +25,6 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.hibernate.HibernateException;
import org.hibernate.jdbc.JDBCContainer;
import org.hibernate.jdbc.JDBCServices;
import org.hibernate.jdbc.impl.LogicalConnectionImplementor;
@@ -36,31 +34,23 @@
*
* @author Steve Ebersole
*/
-public abstract class AbstractStatementProxyHandler implements InvocationHandler {
+public abstract class AbstractStatementProxyHandler extends AbstractProxyHandler {
private static final Logger log = LoggerFactory.getLogger(
AbstractStatementProxyHandler.class );
private ConnectionProxyHandler connectionProxyHandler;
private Connection connectionProxy;
private Statement statement;
- private boolean valid = true;
- private final int hashCode;
protected AbstractStatementProxyHandler(
Statement statement,
ConnectionProxyHandler connectionProxyHandler,
Connection connectionProxy) {
+ super( statement.hashCode() );
this.statement = statement;
this.connectionProxyHandler = connectionProxyHandler;
this.connectionProxy = connectionProxy;
- this.hashCode = statement.hashCode();
}
- private void errorIfInvalid() {
- if ( !valid ) {
- throw new HibernateException( "statment proxy is no longer valid" );
- }
- }
-
protected ConnectionProxyHandler getConnectionProxy() {
errorIfInvalid();
return connectionProxyHandler;
@@ -83,21 +73,10 @@
return statement;
}
- public final Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
+ protected Object continueInvocation(Object proxy, Method method, Object[] args) throws
Throwable {
String methodName = method.getName();
log.trace( "Handling invocation of statement method [{}]", methodName );
- // basic Object methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- if ( "toString".equals( methodName ) ) {
- return this.toString();
- }
- if ( "equals".equals( methodName ) ) {
- return this.equals( args[0] );
- }
- if ( "hashCode".equals( methodName ) ) {
- return this.hashCode();
- }
-
// other methods allowed while invalid
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if ( "close".equals( methodName ) ) {
explicitClose( ( Statement ) proxy );
@@ -121,15 +100,8 @@
beginningInvocationHandling( method, args );
try {
- boolean exposingResultSet = doesMethodExposeResultSet( method );
-
Object result = method.invoke( statement, args );
-
- if ( exposingResultSet ) {
- result = ProxyBuilder.buildResultSet( ( ResultSet ) result, this, ( Statement ) proxy
);
- getJdbcContainer().register( ( ResultSet ) result );
- }
-
+ result = wrapIfNecessary( result, proxy, method );
return result;
}
catch ( InvocationTargetException e ) {
@@ -144,11 +116,27 @@
}
}
+ private Object wrapIfNecessary(Object result, Object proxy, Method method) {
+ if ( !( ResultSet.class.isAssignableFrom( method.getReturnType() ) ) ) {
+ return result;
+ }
+
+ final ResultSet wrapper;
+ if ( "getGeneratedKeys".equals( method.getName() ) ) {
+ wrapper = ProxyBuilder.buildImplicitResultSet( ( ResultSet ) result,
connectionProxyHandler, connectionProxy );
+ }
+ else {
+ wrapper = ProxyBuilder.buildResultSet( ( ResultSet ) result, this, ( Statement ) proxy
);
+ }
+ getJdbcContainer().register( wrapper );
+ return wrapper;
+ }
+
protected void beginningInvocationHandling(Method method, Object[] args) {
}
private void explicitClose(Statement proxy) {
- if ( valid ) {
+ if ( isValid() ) {
LogicalConnectionImplementor lc = getConnectionProxy().getLogicalConnection();
getJdbcContainer().release( proxy );
lc.afterStatementExecution();
@@ -158,20 +146,6 @@
private void invalidateHandle() {
connectionProxyHandler = null;
statement = null;
- valid = false;
+ invalidate();
}
-
- protected boolean doesMethodExposeResultSet(Method method) {
- // todo : we still need to handle getGeneratedKeys, since the resultset there would
expose the statement
- return ResultSet.class.isAssignableFrom( method.getReturnType() )
- && !method.getName().equals( "getGeneratedKeys" );
- }
-
- public String toString() {
- return super.toString() + "[valid=" + valid + "]";
- }
-
- public int hashCode() {
- return hashCode;
- }
}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxyHandler.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ConnectionProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -20,6 +20,7 @@
import java.lang.reflect.Method;
import java.sql.CallableStatement;
import java.sql.Connection;
+import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
@@ -27,7 +28,6 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.hibernate.HibernateException;
import org.hibernate.jdbc.JDBCContainer;
import org.hibernate.jdbc.JDBCServices;
import org.hibernate.jdbc.impl.ConnectionObserver;
@@ -38,17 +38,15 @@
*
* @author Steve Ebersole
*/
-public class ConnectionProxyHandler implements InvocationHandler, ConnectionObserver {
+public class ConnectionProxyHandler extends AbstractProxyHandler implements
InvocationHandler, ConnectionObserver {
private static final Logger log = LoggerFactory.getLogger( ConnectionProxyHandler.class
);
private LogicalConnectionImplementor logicalConnection;
- private boolean valid = true;
- private final int hashCode;
public ConnectionProxyHandler(LogicalConnectionImplementor logicalConnection) {
+ super( logicalConnection.hashCode() );
this.logicalConnection = logicalConnection;
this.logicalConnection.addObserver( this );
- this.hashCode = this.logicalConnection.hashCode();
}
/**
@@ -61,12 +59,6 @@
return logicalConnection;
}
- private void errorIfInvalid() {
- if ( !valid ) {
- throw new HibernateException( "connection handle is invalid" );
- }
- }
-
/**
* Get reference to physical connection.
* <p/>
@@ -100,24 +92,10 @@
return logicalConnection.getJdbcContainer();
}
- /**
- * {@inheritDoc}
- */
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ protected Object continueInvocation(Object proxy, Method method, Object[] args) throws
Throwable {
String methodName = method.getName();
log.trace( "Handling invocation of connection method [{}]", methodName );
- // basic Object methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- if ( "toString".equals( methodName ) ) {
- return this.toString();
- }
- if ( "equals".equals( methodName ) ) {
- return this.equals( args[0] );
- }
- if ( "hashCode".equals( methodName ) ) {
- return this.hashCode();
- }
-
// other methods allowed while invalid
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if ( "close".equals( methodName ) ) {
explicitClose();
@@ -132,34 +110,8 @@
try {
Object result = method.invoke( extractPhysicalConnection(), args );
+ result = wrapIfNecessary( result, proxy, method, args );
- if ( "createStatement".equals( methodName ) ) {
- result = ProxyBuilder.buildStatement(
- ( Statement ) result,
- this,
- ( Connection ) proxy
- );
- getJdbcContainer().register( ( Statement ) result );
- }
- else if ( "prepareStatement".equals( methodName ) ) {
- result = ProxyBuilder.buildPreparedStatement(
- ( String ) args[0],
- ( PreparedStatement ) result,
- this,
- ( Connection ) proxy
- );
- getJdbcContainer().register( ( Statement ) result );
- }
- else if ( "prepareCall".equals( methodName ) ) {
- result = ProxyBuilder.buildCallableStatement(
- ( String ) args[0],
- ( CallableStatement ) result,
- this,
- ( Connection ) proxy
- );
- getJdbcContainer().register( ( Statement ) result );
- }
-
return result;
}
catch( InvocationTargetException e ) {
@@ -174,8 +126,43 @@
}
}
+ private Object wrapIfNecessary(Object result, Object proxy, Method method, Object[]
args) {
+ String methodName = method.getName();
+ Object wrapped = result;
+ if ( "createStatement".equals( methodName ) ) {
+ wrapped = ProxyBuilder.buildStatement(
+ ( Statement ) result,
+ this,
+ ( Connection ) proxy
+ );
+ getJdbcContainer().register( ( Statement ) wrapped );
+ }
+ else if ( "prepareStatement".equals( methodName ) ) {
+ wrapped = ProxyBuilder.buildPreparedStatement(
+ ( String ) args[0],
+ ( PreparedStatement ) result,
+ this,
+ ( Connection ) proxy
+ );
+ getJdbcContainer().register( ( Statement ) wrapped );
+ }
+ else if ( "prepareCall".equals( methodName ) ) {
+ wrapped = ProxyBuilder.buildCallableStatement(
+ ( String ) args[0],
+ ( CallableStatement ) result,
+ this,
+ ( Connection ) proxy
+ );
+ getJdbcContainer().register( ( Statement ) wrapped );
+ }
+ else if ( "getMetaData".equals( methodName ) ) {
+ wrapped = ProxyBuilder.buildDatabaseMetaData( ( DatabaseMetaData ) result, this, (
Connection ) proxy );
+ }
+ return wrapped;
+ }
+
private void explicitClose() {
- if ( valid ) {
+ if ( isValid() ) {
invalidateHandle();
}
}
@@ -183,7 +170,7 @@
private void invalidateHandle() {
log.trace( "Invalidating connection handle" );
logicalConnection = null;
- valid = false;
+ invalidate();
}
/**
@@ -206,12 +193,4 @@
log.info( "*** logical connection closed ***" );
invalidateHandle();
}
-
- public String toString() {
- return super.toString() + "[valid=" + valid + "]";
- }
-
- public int hashCode() {
- return hashCode;
- }
}
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/DatabaseMetaDataProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/DatabaseMetaDataProxyHandler.java
(rev 0)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/DatabaseMetaDataProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * The InvocationHandler for intercepting messages to {@link DatabaseMetaData} proxies.
+ * <p/>
+ * Mainly we need to intercept the methods defined on {@link DatabaseMetaData} which
expose
+ * {@link java.sql.ResultSet} instances, which in turn expose {@link java.sql.Statement}
+ * instances, which in turn...
+ *
+ * @author Steve Ebersole
+ */
+public class DatabaseMetaDataProxyHandler extends AbstractProxyHandler {
+ private ConnectionProxyHandler connectionProxyHandler;
+ private Connection connectionProxy;
+ private DatabaseMetaData databaseMetaData;
+
+ public DatabaseMetaDataProxyHandler(DatabaseMetaData databaseMetaData,
ConnectionProxyHandler connectionProxyHandler, Connection connectionProxy) {
+ super( databaseMetaData.hashCode() );
+ this.connectionProxyHandler = connectionProxyHandler;
+ this.connectionProxy = connectionProxy;
+ this.databaseMetaData = databaseMetaData;
+ }
+
+ protected Object continueInvocation(Object proxy, Method method, Object[] args) throws
Throwable {
+ try {
+ boolean exposingResultSet = doesMethodExposeResultSet( method );
+
+ Object result = method.invoke( databaseMetaData, args );
+
+ if ( exposingResultSet ) {
+ result = ProxyBuilder.buildImplicitResultSet( ( ResultSet ) result,
connectionProxyHandler, connectionProxy );
+ connectionProxyHandler.getJdbcContainer().register( ( ResultSet ) result );
+ }
+
+ return result;
+ }
+ catch ( InvocationTargetException e ) {
+ Throwable realException = e.getTargetException();
+ if ( SQLException.class.isInstance( realException ) ) {
+ throw connectionProxyHandler.getJdbcServices().getExceptionHelper()
+ .convert( ( SQLException ) realException, realException.getMessage() );
+ }
+ else {
+ throw realException;
+ }
+ }
+ }
+
+ protected boolean doesMethodExposeResultSet(Method method) {
+ return ResultSet.class.isAssignableFrom( method.getReturnType() );
+ }
+
+}
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitResultSetProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitResultSetProxyHandler.java
(rev 0)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitResultSetProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.sql.SQLException;
+
+import org.hibernate.jdbc.JDBCContainer;
+import org.hibernate.jdbc.JDBCServices;
+
+/**
+ * ImplicitResultSetProxyHandler implementation
+ *
+ * @author Steve Ebersole
+ */
+public class ImplicitResultSetProxyHandler extends AbstractResultSetProxyHandler {
+ private ConnectionProxyHandler connectionProxyHandler;
+ private Connection connectionProxy;
+ private Statement sourceStatement;
+
+ public ImplicitResultSetProxyHandler(ResultSet resultSet, ConnectionProxyHandler
connectionProxyHandler, Connection connectionProxy) {
+ super( resultSet );
+ this.connectionProxyHandler = connectionProxyHandler;
+ this.connectionProxy = connectionProxy;
+ }
+
+ protected JDBCServices getJdbcServices() {
+ return connectionProxyHandler.getJdbcServices();
+ }
+
+ protected JDBCContainer getJdbcContainer() {
+ return connectionProxyHandler.getJdbcContainer();
+ }
+
+ protected Statement getExposeableStatement() {
+ if ( sourceStatement == null ) {
+ try {
+ Statement stmnt = getResultSet().getStatement();
+ sourceStatement = ProxyBuilder.buildImplicitStatement( stmnt, connectionProxyHandler,
connectionProxy );
+ }
+ catch ( SQLException e ) {
+ throw getJdbcServices().getExceptionHelper().convert( e, e.getMessage() );
+ }
+ }
+ return sourceStatement;
+ }
+
+ protected void invalidateHandle() {
+ sourceStatement = null;
+ super.invalidateHandle();
+ }
+}
Added:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitStatementProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitStatementProxyHandler.java
(rev 0)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ImplicitStatementProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, v. 2.1. This program is distributed in the
+ * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details. You should have received a
+ * copy of the GNU Lesser General Public License, v.2.1 along with this
+ * distribution; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Red Hat Author(s): Steve Ebersole
+ */
+package org.hibernate.jdbc.proxy;
+
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.Statement;
+
+import org.hibernate.HibernateException;
+
+/**
+ * ImplicitStatementProxyHandler implementation
+ *
+ * @author Steve Ebersole
+ */
+public class ImplicitStatementProxyHandler extends AbstractStatementProxyHandler {
+ protected ImplicitStatementProxyHandler(Statement statement, ConnectionProxyHandler
connectionProxyHandler, Connection connectionProxy) {
+ super( statement, connectionProxyHandler, connectionProxy );
+ }
+
+ protected void beginningInvocationHandling(Method method, Object[] args) {
+ // disallow executions...
+ if ( method.getName().startsWith( "execute" ) ) {
+ throw new HibernateException( "execution not allowed on implicit statement
object" );
+ }
+ }
+}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyBuilder.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyBuilder.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyBuilder.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -18,6 +18,7 @@
import java.lang.reflect.Proxy;
import java.sql.CallableStatement;
import java.sql.Connection;
+import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
@@ -57,6 +58,7 @@
ResultSetWrapperImplementor.class
};
+ public static final Class[] METADATA_PROXY_INTERFACES = new Class[] {
DatabaseMetaData.class };
public static Connection buildConnection(LogicalConnectionImplementor logicalConnection)
{
ConnectionProxyHandler proxyHandler = new ConnectionProxyHandler( logicalConnection );
@@ -130,4 +132,40 @@
proxyHandler
);
}
+
+ public static DatabaseMetaData buildDatabaseMetaData(
+ DatabaseMetaData metaData,
+ ConnectionProxyHandler connectionProxyHandler,
+ Connection connectionProxy) {
+ DatabaseMetaDataProxyHandler handler = new DatabaseMetaDataProxyHandler( metaData,
connectionProxyHandler, connectionProxy );
+ return ( DatabaseMetaData ) Proxy.newProxyInstance(
+ DatabaseMetaDataProxyHandler.class.getClassLoader(),
+ METADATA_PROXY_INTERFACES,
+ handler
+ );
+ }
+
+ public static ResultSet buildImplicitResultSet(
+ ResultSet resultSet,
+ ConnectionProxyHandler connectionProxyHandler,
+ Connection connectionProxy) {
+ ImplicitResultSetProxyHandler proxyHandler = new ImplicitResultSetProxyHandler(
resultSet, connectionProxyHandler, connectionProxy );
+ return ( ResultSet ) Proxy.newProxyInstance(
+ ResultSetWrapperImplementor.class.getClassLoader(),
+ RESULTSET_PROXY_INTERFACES,
+ proxyHandler
+ );
+ }
+
+ public static Statement buildImplicitStatement(
+ Statement statement,
+ ConnectionProxyHandler connectionProxyHandler,
+ Connection connectionProxy) {
+ ImplicitStatementProxyHandler handler = new ImplicitStatementProxyHandler( statement,
connectionProxyHandler, connectionProxy );
+ return ( Statement ) Proxy.newProxyInstance(
+ StatementWrapperImplementor.class.getClassLoader(),
+ STMNT_PROXY_INTERFACES,
+ handler
+ );
+ }
}
Deleted:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyJDBCContainer.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyJDBCContainer.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ProxyJDBCContainer.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved.
- *
- * This copyrighted material is made available to anyone wishing to use, modify,
- * copy, or redistribute it subject to the terms and conditions of the GNU
- * Lesser General Public License, v. 2.1. This program is distributed in the
- * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details. You should have received a
- * copy of the GNU Lesser General Public License, v.2.1 along with this
- * distribution; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Red Hat Author(s): Steve Ebersole
- */
-package org.hibernate.jdbc.proxy;
-
-import java.sql.ResultSet;
-import java.sql.Statement;
-
-import org.hibernate.jdbc.impl.BasicJDBCContainer;
-import org.hibernate.jdbc.impl.ResultSetWrapperImplementor;
-import org.hibernate.jdbc.impl.StatementWrapperImplementor;
-import org.hibernate.jdbc.util.ExceptionHelper;
-
-/**
- * ProxyJDBCContainer implementation
- *
- * @author Steve Ebersole
- */
-public class ProxyJDBCContainer extends BasicJDBCContainer {
- public ProxyJDBCContainer(ExceptionHelper exceptionHelper) {
- super( exceptionHelper );
- }
-
- protected void close(Statement statement) {
- if ( statement instanceof StatementWrapperImplementor ) {
- StatementWrapperImplementor wrapper = ( StatementWrapperImplementor ) statement;
- super.close( wrapper.getWrappedStatement() );
- wrapper.invalidate();
- }
- else {
- super.close( statement );
- }
- }
-
- protected void close(ResultSet resultSet) {
- if ( resultSet instanceof ResultSetWrapperImplementor ) {
- ResultSetWrapperImplementor wrapper = ( ResultSetWrapperImplementor ) resultSet;
- super.close( wrapper.getWrappedResultSet() );
- wrapper.invalidate();
- }
- else {
- super.close( resultSet );
- }
- }
-}
Modified:
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxyHandler.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxyHandler.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/main/java/org/hibernate/jdbc/proxy/ResultSetProxyHandler.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -15,17 +15,9 @@
*/
package org.hibernate.jdbc.proxy;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
import java.sql.ResultSet;
-import java.sql.SQLException;
import java.sql.Statement;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import org.hibernate.HibernateException;
import org.hibernate.jdbc.JDBCContainer;
import org.hibernate.jdbc.JDBCServices;
@@ -34,44 +26,27 @@
*
* @author Steve Ebersole
*/
-public class ResultSetProxyHandler implements InvocationHandler {
- private static final Logger log = LoggerFactory.getLogger( ResultSetProxyHandler.class
);
-
+public class ResultSetProxyHandler extends AbstractResultSetProxyHandler {
private AbstractStatementProxyHandler statementProxyHandler;
private Statement statementProxy;
- private ResultSet resultSet;
- private boolean valid = true;
- private final int hashCode;
public ResultSetProxyHandler(
ResultSet resultSet,
AbstractStatementProxyHandler statementProxyHandler,
Statement statementProxy) {
- this.resultSet = resultSet;
+ super( resultSet );
this.statementProxyHandler = statementProxyHandler;
this.statementProxy = statementProxy;
- this.hashCode = resultSet.hashCode();
}
- protected ResultSet getResultSet() {
- errorIfInvalid();
- return resultSet;
- }
-
- protected ResultSet getResultSetWithoutChecks() {
- return resultSet;
- }
-
- protected void errorIfInvalid() {
- if ( !valid ) {
- throw new HibernateException( "resultset handle is no longer valid" );
- }
- }
-
protected AbstractStatementProxyHandler getStatementProxy() {
return statementProxyHandler;
}
+ protected Statement getExposeableStatement() {
+ return statementProxy;
+ }
+
protected JDBCServices getJdbcServices() {
return getStatementProxy().getJdbcServices();
}
@@ -80,73 +55,8 @@
return getStatementProxy().getJdbcContainer();
}
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- String methodName = method.getName();
- log.trace( "Handling invocation of resultset method [{}]", methodName );
-
- // basic Object methods
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- if ( "toString".equals( methodName ) ) {
- return this.toString();
- }
- if ( "equals".equals( methodName ) ) {
- return this.equals( args[0] );
- }
- if ( "hashCode".equals( methodName ) ) {
- return this.hashCode();
- }
-
- // other methods allowed while invalid
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- if ( "close".equals( methodName ) ) {
- explicitClose( ( ResultSet ) proxy );
- return null;
- }
- if ( "invalidate".equals( methodName ) ) {
- invalidateHandle();
- return null;
- }
-
- errorIfInvalid();
-
- if ( "getWrappedResultSet".equals( methodName ) ) {
- return getResultSetWithoutChecks();
- }
-
- if ( "getStatement".equals( methodName ) ) {
- return statementProxy;
- }
-
- try {
- return method.invoke( resultSet, args );
- }
- catch ( InvocationTargetException e ) {
- Throwable realException = e.getTargetException();
- if ( SQLException.class.isInstance( realException ) ) {
- throw getJdbcServices().getExceptionHelper()
- .convert( ( SQLException ) realException, realException.getMessage() );
- }
- else {
- throw realException;
- }
- }
- }
-
- private void explicitClose(ResultSet proxy) {
- if ( valid ) {
- statementProxyHandler.getJdbcContainer().release( proxy );
- }
- }
-
- private void invalidateHandle() {
+ protected void invalidateHandle() {
statementProxyHandler = null;
- resultSet = null;
- valid = false;
+ super.invalidateHandle();
}
-
- public String toString() {
- return super.toString() + "[valid=" + valid + "]";
- }
-
- public int hashCode() {
- return hashCode;
- }
}
Modified:
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/batch/TestingServiceImpl.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/batch/TestingServiceImpl.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/batch/TestingServiceImpl.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -15,17 +15,11 @@
*/
package org.hibernate.jdbc.batch;
-import java.sql.SQLException;
-
-import org.hibernate.cfg.Settings;
import org.hibernate.connection.ConnectionProvider;
-import org.hibernate.exception.SQLStateConverter;
-import org.hibernate.exception.ViolatedConstraintNameExtracter;
import org.hibernate.jdbc.ConnectionProviderBuilder;
-import org.hibernate.jdbc.JDBCContainer;
import org.hibernate.jdbc.JDBCContainerBuilder;
import org.hibernate.jdbc.JDBCServices;
-import org.hibernate.jdbc.proxy.ProxyJDBCContainer;
+import org.hibernate.jdbc.impl.BasicJDBCContainerBuilder;
import org.hibernate.jdbc.util.ExceptionHelper;
import org.hibernate.jdbc.util.SQLStatementLogger;
@@ -43,20 +37,8 @@
public void prepare(boolean allowAggressiveRelease) {
connectionProvider = ConnectionProviderBuilder.buildConnectionProvider(
allowAggressiveRelease );
sqlStatementLogger = new SQLStatementLogger( true );
- exceptionHelper = new ExceptionHelper(
- new SQLStateConverter(
- new ViolatedConstraintNameExtracter() {
- public String extractConstraintName(SQLException e) {
- return null;
- }
- }
- )
- );
- jdbcContainerBuilder = new JDBCContainerBuilder() {
- public JDBCContainer buildJdbcContainer() {
- return new ProxyJDBCContainer( exceptionHelper );
- }
- };
+ exceptionHelper = new ExceptionHelper();
+ jdbcContainerBuilder = new BasicJDBCContainerBuilder( exceptionHelper );
}
public void release() {
Modified:
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/delegation/TestingServiceImpl.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/delegation/TestingServiceImpl.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/delegation/TestingServiceImpl.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -18,7 +18,7 @@
import org.hibernate.jdbc.JDBCServices;
import org.hibernate.jdbc.JDBCContainerBuilder;
import org.hibernate.jdbc.ConnectionProviderBuilder;
-import org.hibernate.jdbc.JDBCContainer;
+import org.hibernate.jdbc.impl.BasicJDBCContainerBuilder;
import org.hibernate.jdbc.util.SQLStatementLogger;
import org.hibernate.jdbc.util.ExceptionHelper;
import org.hibernate.connection.ConnectionProvider;
@@ -38,11 +38,7 @@
connectionProvider = ConnectionProviderBuilder.buildConnectionProvider(
allowAggressiveRelease );
sqlStatementLogger = new SQLStatementLogger( true );
exceptionHelper = new ExceptionHelper();
- jdbcContainerBuilder = new JDBCContainerBuilder() {
- public JDBCContainer buildJdbcContainer() {
- return new DelegateJDBCContainer( exceptionHelper );
- }
- };
+ jdbcContainerBuilder = new BasicJDBCContainerBuilder( exceptionHelper );
}
public void release() {
Modified:
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/impl/TestingServiceImpl.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/impl/TestingServiceImpl.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/impl/TestingServiceImpl.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -20,12 +20,9 @@
import org.hibernate.jdbc.JDBCServices;
import org.hibernate.jdbc.JDBCContainerBuilder;
import org.hibernate.jdbc.ConnectionProviderBuilder;
-import org.hibernate.jdbc.JDBCContainer;
import org.hibernate.jdbc.util.SQLStatementLogger;
import org.hibernate.jdbc.util.ExceptionHelper;
import org.hibernate.connection.ConnectionProvider;
-import org.hibernate.exception.SQLStateConverter;
-import org.hibernate.exception.ViolatedConstraintNameExtracter;
/**
* TestingServiceImpl implementation
@@ -41,20 +38,8 @@
public void prepare() {
connectionProvider = ConnectionProviderBuilder.buildConnectionProvider();
sqlStatementLogger = new SQLStatementLogger( true );
- exceptionHelper = new ExceptionHelper(
- new SQLStateConverter(
- new ViolatedConstraintNameExtracter() {
- public String extractConstraintName(SQLException e) {
- return null;
- }
- }
- )
- );
- jdbcContainerBuilder = new JDBCContainerBuilder() {
- public JDBCContainer buildJdbcContainer() {
- return new BasicJDBCContainer( exceptionHelper );
- }
- };
+ exceptionHelper = new ExceptionHelper();
+ jdbcContainerBuilder = new BasicJDBCContainerBuilder( exceptionHelper );
}
public void release() {
Modified:
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/BasicConnectionProxyTest.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -15,24 +15,24 @@
*/
package org.hibernate.jdbc.proxy;
-import java.lang.reflect.Proxy;
import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
-import java.sql.PreparedStatement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.assertFalse;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import org.hibernate.ConnectionReleaseMode;
import org.hibernate.JDBCException;
-import org.hibernate.jdbc.ConnectionWrapper;
import org.hibernate.jdbc.impl.LogicalConnectionImpl;
/**
@@ -56,6 +56,30 @@
}
@Test
+ public void testDatabaseMetaDataHandling() throws Throwable {
+ LogicalConnectionImpl logicalConnection = new LogicalConnectionImpl( null,
ConnectionReleaseMode.AFTER_TRANSACTION, services );
+ Connection proxiedConnection = ProxyBuilder.buildConnection( logicalConnection );
+ try {
+ DatabaseMetaData metaData = proxiedConnection.getMetaData();
+ assertFalse( logicalConnection.getJdbcContainer().hasRegisteredResources() );
+ ResultSet rs1 = metaData.getCatalogs();
+ assertTrue( logicalConnection.getJdbcContainer().hasRegisteredResources() );
+ rs1.close();
+ assertFalse( logicalConnection.getJdbcContainer().hasRegisteredResources() );
+ metaData.getCatalogs();
+ metaData.getSchemas();
+ assertTrue( logicalConnection.getJdbcContainer().hasRegisteredResources() );
+ }
+ catch ( SQLException sqle ) {
+ fail( "incorrect exception type : sqlexception" );
+ }
+ finally {
+ logicalConnection.close();
+ assertFalse( logicalConnection.getJdbcContainer().hasRegisteredResources() );
+ }
+ }
+
+ @Test
public void testExceptionHandling() {
LogicalConnectionImpl logicalConnection = new LogicalConnectionImpl( null,
ConnectionReleaseMode.AFTER_TRANSACTION, services );
Connection proxiedConnection = ProxyBuilder.buildConnection( logicalConnection );
Modified:
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/TestingServiceImpl.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/TestingServiceImpl.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/java/org/hibernate/jdbc/proxy/TestingServiceImpl.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -20,12 +20,10 @@
import org.hibernate.jdbc.JDBCServices;
import org.hibernate.jdbc.JDBCContainerBuilder;
import org.hibernate.jdbc.ConnectionProviderBuilder;
-import org.hibernate.jdbc.JDBCContainer;
+import org.hibernate.jdbc.impl.BasicJDBCContainerBuilder;
import org.hibernate.jdbc.util.SQLStatementLogger;
import org.hibernate.jdbc.util.ExceptionHelper;
import org.hibernate.connection.ConnectionProvider;
-import org.hibernate.exception.SQLStateConverter;
-import org.hibernate.exception.ViolatedConstraintNameExtracter;
/**
* TestingServiceImpl implementation
@@ -41,20 +39,8 @@
public void prepare(boolean allowAggressiveRelease) {
connectionProvider = ConnectionProviderBuilder.buildConnectionProvider(
allowAggressiveRelease );
sqlStatementLogger = new SQLStatementLogger( true );
- exceptionHelper = new ExceptionHelper(
- new SQLStateConverter(
- new ViolatedConstraintNameExtracter() {
- public String extractConstraintName(SQLException e) {
- return null;
- }
- }
- )
- );
- jdbcContainerBuilder = new JDBCContainerBuilder() {
- public JDBCContainer buildJdbcContainer() {
- return new ProxyJDBCContainer( exceptionHelper );
- }
- };
+ exceptionHelper = new ExceptionHelper();
+ jdbcContainerBuilder = new BasicJDBCContainerBuilder( exceptionHelper );
}
public void release() {
Modified: sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/PerformanceTest.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/PerformanceTest.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/PerformanceTest.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -129,9 +129,6 @@
System.gc();
System.gc();
- Connection c;
- LogicalConnectionImpl lc;
-
// prime
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for ( int a = 0, Z = datums.length; a < Z; a++ ) {
Modified:
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/TestingServiceImpl.java
===================================================================
---
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/TestingServiceImpl.java 2007-08-22
05:14:13 UTC (rev 13947)
+++
sandbox/trunk/jdbc-proxy/src/test/perf/org/hibernate/jdbc/TestingServiceImpl.java 2007-08-22
15:36:17 UTC (rev 13948)
@@ -15,14 +15,10 @@
*/
package org.hibernate.jdbc;
-import java.sql.SQLException;
-
-import org.hibernate.jdbc.proxy.ProxyJDBCContainer;
-import org.hibernate.jdbc.util.SQLStatementLogger;
-import org.hibernate.jdbc.util.ExceptionHelper;
import org.hibernate.connection.ConnectionProvider;
-import org.hibernate.exception.SQLStateConverter;
-import org.hibernate.exception.ViolatedConstraintNameExtracter;
+import org.hibernate.jdbc.impl.BasicJDBCContainerBuilder;
+import org.hibernate.jdbc.util.ExceptionHelper;
+import org.hibernate.jdbc.util.SQLStatementLogger;
/**
* TestingServiceImpl implementation
@@ -38,20 +34,8 @@
public void prepare(boolean allowAggressiveRelease) {
connectionProvider = ConnectionProviderBuilder.buildConnectionProvider(
allowAggressiveRelease );
sqlStatementLogger = new SQLStatementLogger( false );
- exceptionHelper = new ExceptionHelper(
- new SQLStateConverter(
- new ViolatedConstraintNameExtracter() {
- public String extractConstraintName(SQLException e) {
- return null;
- }
- }
- )
- );
- jdbcContainerBuilder = new JDBCContainerBuilder() {
- public JDBCContainer buildJdbcContainer() {
- return new ProxyJDBCContainer( exceptionHelper );
- }
- };
+ exceptionHelper = new ExceptionHelper();
+ jdbcContainerBuilder = new BasicJDBCContainerBuilder( exceptionHelper );
}
public void release() {