Author: gbadner Date: 2009-03-31 02:43:12 -0400 (Tue, 31 Mar 2009) New Revision: 16233 Added: core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapper.java Removed: core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateExceptionConverterJDBC4.java core/branches/Branch_3_2/src/org/hibernate/exception/TransactionRollbackException.java core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapperProxy.java core/branches/Branch_3_2/src/org/hibernate/lob/BlobImplProxy.java core/branches/Branch_3_2/src/org/hibernate/lob/ClobImplProxy.java core/branches/Branch_3_2/src/org/hibernate/lob/LobCreator.java core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorFactory.java core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC3.java core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC4.java core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlobProxy.java core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClobProxy.java core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobFromLobCreatorTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobFromLobCreatorTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorDefaultTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3ConnRelOnCloseTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3Test.java core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4ConnRelOnCloseTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4Test.java core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorDefaultTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3ConnRelOnCloseTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3Test.java core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4ConnRelOnCloseTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4Test.java Modified: core/branches/Branch_3_2/src/org/hibernate/Hibernate.java core/branches/Branch_3_2/src/org/hibernate/cfg/Environment.java core/branches/Branch_3_2/src/org/hibernate/cfg/Settings.java core/branches/Branch_3_2/src/org/hibernate/cfg/SettingsFactory.java core/branches/Branch_3_2/src/org/hibernate/dialect/Dialect.java core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateConverter.java core/branches/Branch_3_2/src/org/hibernate/jdbc/ColumnNameCache.java core/branches/Branch_3_2/src/org/hibernate/loader/Loader.java core/branches/Branch_3_2/src/org/hibernate/lob/BlobImpl.java core/branches/Branch_3_2/src/org/hibernate/lob/ClobImpl.java core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlob.java core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClob.java core/branches/Branch_3_2/src/org/hibernate/type/BlobType.java core/branches/Branch_3_2/src/org/hibernate/type/ClobType.java core/branches/Branch_3_2/test/org/hibernate/test/AllTests.java core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobTest.java core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobTest.java Log: HHH-2412 : back out of changes for compiling with JDK 1.6 and JDBC4 API usage Modified: core/branches/Branch_3_2/src/org/hibernate/Hibernate.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/Hibernate.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/Hibernate.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -14,8 +14,10 @@ import org.hibernate.engine.HibernateIterator; import org.hibernate.intercept.FieldInterceptionHelper; import org.hibernate.intercept.FieldInterceptor; -import org.hibernate.lob.LobCreator; -import org.hibernate.lob.LobCreatorFactory; +import org.hibernate.lob.BlobImpl; +import org.hibernate.lob.ClobImpl; +import org.hibernate.lob.SerializableBlob; +import org.hibernate.lob.SerializableClob; import org.hibernate.proxy.HibernateProxy; import org.hibernate.proxy.LazyInitializer; import org.hibernate.type.AnyType; @@ -346,30 +348,13 @@ } /** - * If the setting for Environment#USE_CONNECTION_FOR_LOB_CREATION is true, then the - * returned LobCreator will use the Connection to create LOBs. If it is false, then - * the returned LobCreator will not use the Connection to create LOBs. - * - * If the property is not set, then the returned LobCreator will use the connection to - * create LOBs only if the JVM and JDBC driver support this JDBC4 functionality. - * - * (@see Environment#USE_CONNECTION_FOR_LOB_CREATION) - * - * @param session The session. - * @return the LobCreator - */ - public static LobCreator getLobCreator(Session session) { - return LobCreatorFactory.createLobCreator( session ); - } - - /** * Create a new <tt>Blob</tt>. The returned object will be initially immutable. * * @param bytes a byte array * @return the Blob */ public static Blob createBlob(byte[] bytes) { - return LobCreatorFactory.createLobCreator().createBlob( bytes ); + return new SerializableBlob( new BlobImpl( bytes ) ); } /** @@ -379,8 +364,8 @@ * @param length the number of bytes in the stream * @return the Blob */ - public static Blob createBlob(InputStream stream, int length) throws HibernateException, IOException { - return LobCreatorFactory.createLobCreator().createBlob( stream, length ); + public static Blob createBlob(InputStream stream, int length) { + return new SerializableBlob( new BlobImpl( stream, length ) ); } /** @@ -390,8 +375,8 @@ * @return the Blob * @throws IOException */ - public static Blob createBlob(InputStream stream) throws HibernateException, IOException { - return LobCreatorFactory.createLobCreator().createBlob( stream, stream.available() ); + public static Blob createBlob(InputStream stream) throws IOException { + return new SerializableBlob( new BlobImpl( stream, stream.available() ) ); } /** @@ -399,8 +384,8 @@ * * @param string a <tt>String</tt> */ - public static Clob createClob(String string) throws HibernateException { - return LobCreatorFactory.createLobCreator().createClob( string ); + public static Clob createClob(String string) { + return new SerializableClob( new ClobImpl( string ) ); } /** @@ -409,8 +394,8 @@ * @param reader a character stream * @param length the number of characters in the stream */ - public static Clob createClob(Reader reader, int length) throws HibernateException, IOException { - return LobCreatorFactory.createLobCreator().createClob( reader, length ); + public static Clob createClob(Reader reader, int length) { + return new SerializableClob( new ClobImpl( reader, length ) ); } /** Modified: core/branches/Branch_3_2/src/org/hibernate/cfg/Environment.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/cfg/Environment.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/cfg/Environment.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -111,16 +111,11 @@ * this property when using user supplied connections)</td> * </tr> * <tr> - * <td><tt>hibernate.jdbc.use_get_generated_keys</tt></td> + * <td><tt>hibernate.jdbc.use_getGeneratedKeys</tt></td> * <td>enable use of JDBC3 PreparedStatement.getGeneratedKeys() to retrieve * natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+</td> * </tr> * <tr> - * <td><tt>hibernate.jdbc.use_connection_for_lob_creation</tt></td> - * <td>enable use of JDBC4 Connection.createBlob() and Connection.createClob() to - * create Blobs and Clobs. Requires JDBC4+ driver and JRE1.6+</td> - * </tr> - * <tr> * <td><tt>hibernate.hbm2ddl.auto</tt></td> * <td>enable auto DDL export</td> * </tr> @@ -267,13 +262,6 @@ */ public static final String USE_GET_GENERATED_KEYS = "hibernate.jdbc.use_get_generated_keys"; /** - * Tells the JDBC driver to attempt to create Blobs and Clobs using JDBC 4.0 - * Connection.createBlob() and Connection.createClob(), respectively. - * Performance may be better if this property is set to true and the underlying JDBC driver - * supports these Connection methods. - */ - public static final String USE_CONNECTION_FOR_LOB_CREATION = "hibernate.jdbc.use_connection_for_lob_creation"; - /** * Gives the JDBC driver a hint as to the number of rows that should be fetched from the database * when more rows are needed. If <tt>0</tt>, JDBC driver default settings will be used. */ @@ -490,7 +478,6 @@ private static final boolean JVM_HAS_TIMESTAMP_BUG; private static final boolean JVM_HAS_JDK14_TIMESTAMP; private static final boolean JVM_SUPPORTS_GET_GENERATED_KEYS; - private static final boolean JVM_SUPPORTS_JDBC4; private static final Properties GLOBAL_PROPERTIES; private static final HashMap ISOLATION_LEVELS = new HashMap(); @@ -591,18 +578,6 @@ JVM_SUPPORTS_GET_GENERATED_KEYS = getGeneratedKeysSupport; if (!JVM_SUPPORTS_GET_GENERATED_KEYS) log.info("JVM does not support Statement.getGeneratedKeys()"); - boolean jvmSupportsJDBC4; - try { - Connection.class.getMethod("createBlob", null); - Connection.class.getMethod("createClob", null); - jvmSupportsJDBC4 = true; - } - catch (NoSuchMethodException nsme) { - jvmSupportsJDBC4 = false; - } - JVM_SUPPORTS_JDBC4 = jvmSupportsJDBC4; - if (!JVM_SUPPORTS_JDBC4 ) log.info("JVM does not support JDBC4"); - boolean linkedHashSupport; try { Class.forName("java.util.LinkedHashSet"); @@ -658,10 +633,6 @@ return JVM_SUPPORTS_GET_GENERATED_KEYS; } - public static boolean jvmSupportsJDBC4() { - return JVM_SUPPORTS_JDBC4; - } - /** * Should we use streams to bind binary types to JDBC IN parameters. * Property <tt>hibernate.jdbc.use_streams_for_binary</tt>. Modified: core/branches/Branch_3_2/src/org/hibernate/cfg/Settings.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/cfg/Settings.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/cfg/Settings.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -32,7 +32,6 @@ private int defaultBatchFetchSize; private boolean scrollableResultSetsEnabled; private boolean getGeneratedKeysEnabled; - private boolean useConnectionForLobCreationEnabled; private String defaultSchemaName; private String defaultCatalogName; private Integer jdbcFetchSize; @@ -125,10 +124,6 @@ return getGeneratedKeysEnabled; } - public boolean isUseConnectionForLobCreationEnabled() { - return useConnectionForLobCreationEnabled; - } - public boolean isMinimalPutsEnabled() { return minimalPutsEnabled; } @@ -324,10 +319,6 @@ getGeneratedKeysEnabled = b; } - void setUseConnectionForLobCreationEnabled(boolean b) { - useConnectionForLobCreationEnabled = b; - } - void setJdbcFetchSize(Integer integer) { jdbcFetchSize = integer; } Modified: core/branches/Branch_3_2/src/org/hibernate/cfg/SettingsFactory.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/cfg/SettingsFactory.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/cfg/SettingsFactory.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -71,7 +71,6 @@ boolean metaSupportsBatchUpdates = false; boolean metaReportsDDLCausesTxnCommit = false; boolean metaReportsDDLInTxnSupported = true; - boolean driverConnectionHasLobCreationMethods = false; // 'hibernate.temp.use_jdbc_metadata_defaults' is a temporary magic value. // The need for it is intended to be alleviated with 3.3 developement, thus it is @@ -109,31 +108,7 @@ } } - if ( Environment.jvmSupportsJDBC4() ) { - try { - // this block doesn't actually use the DatabaseMetaData, but it does use the - // driver Connection Class to determine if methods are present. - Class c = conn.getClass(); - if ( Connection.class.equals( c.getMethod( "createBlob", null ).getDeclaringClass() ) || - Connection.class.equals( c.getMethod( "createClob", null ).getDeclaringClass() ) ) { - driverConnectionHasLobCreationMethods = false; - } - else { - // the driver's Connection class has all three methods; - // can't tell if the driver actually supports these methods w/o calling them, - // but don't want to actually create a LOB here. - driverConnectionHasLobCreationMethods = true; - } - } - catch (AbstractMethodError ame) { - driverConnectionHasLobCreationMethods = false; - } - catch (Exception e) { - driverConnectionHasLobCreationMethods = false; - } - } } - finally { connections.closeConnection(conn); } @@ -195,10 +170,6 @@ log.info("JDBC3 getGeneratedKeys(): " + enabledDisabled(useGetGeneratedKeys) ); settings.setGetGeneratedKeysEnabled(useGetGeneratedKeys); - boolean useConnectionForLobCreation = PropertiesHelper.getBoolean(Environment.USE_CONNECTION_FOR_LOB_CREATION, properties, driverConnectionHasLobCreationMethods); - log.info("JDBC4 Connection.createBlob() and Connection.createClob(): " + enabledDisabled(useConnectionForLobCreation) ); - settings.setUseConnectionForLobCreationEnabled(useConnectionForLobCreation); - Integer statementFetchSize = PropertiesHelper.getInteger(Environment.STATEMENT_FETCH_SIZE, properties); if (statementFetchSize!=null) log.info("JDBC result set fetch size: " + statementFetchSize); settings.setJdbcFetchSize(statementFetchSize); Modified: core/branches/Branch_3_2/src/org/hibernate/dialect/Dialect.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/dialect/Dialect.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/dialect/Dialect.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -52,7 +52,6 @@ import org.hibernate.exception.SQLExceptionConverter; import org.hibernate.exception.SQLStateConverter; import org.hibernate.exception.ViolatedConstraintNameExtracter; -import org.hibernate.exception.SQLStateExceptionConverterJDBC4; import org.hibernate.id.IdentityGenerator; import org.hibernate.id.SequenceGenerator; import org.hibernate.id.TableHiLoGenerator; @@ -1224,14 +1223,9 @@ */ public SQLExceptionConverter buildSQLExceptionConverter() { // The default SQLExceptionConverter for all dialects is based on SQLState - // since SQLErrorCode is extremely vendor-specific. If JDBC4 is supported, - // then the default SQLExceptionConverter will convert based on JDBC4 - // SQLException if the SQLState is not recognized. Specific Dialects + // since SQLErrorCode is extremely vendor-specific. Specific Dialects // may override to return whatever is most appropriate for that vendor. - return ( Environment.jvmSupportsJDBC4() ? - new SQLStateExceptionConverterJDBC4( getViolatedConstraintNameExtracter() ) : - new SQLStateConverter( getViolatedConstraintNameExtracter() ) - ); + return new SQLStateConverter( getViolatedConstraintNameExtracter() ); } private static final ViolatedConstraintNameExtracter EXTRACTER = new ViolatedConstraintNameExtracter() { Modified: core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateConverter.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateConverter.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateConverter.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -24,7 +24,6 @@ private static final Set DATA_CATEGORIES = new HashSet(); private static final Set INTEGRITY_VIOLATION_CATEGORIES = new HashSet(); private static final Set CONNECTION_CATEGORIES = new HashSet(); - private static final Set TRANSACTION_ROLLBACK_CATEGORIES = new HashSet(); static { SQL_GRAMMAR_CATEGORIES.add( "07" ); @@ -43,19 +42,12 @@ INTEGRITY_VIOLATION_CATEGORIES.add( "44" ); CONNECTION_CATEGORIES.add( "08" ); - CONNECTION_CATEGORIES.add( "28" ); - - TRANSACTION_ROLLBACK_CATEGORIES.add( "40" ); } public SQLStateConverter(ViolatedConstraintNameExtracter extracter) { this.extracter = extracter; } - protected String getViolatedConstraintName(SQLException sqlException) { - return extracter.extractConstraintName( sqlException ); - } - /** * Convert the given SQLException into Hibernate's JDBCException hierarchy. * @@ -75,7 +67,7 @@ return new SQLGrammarException( message, sqlException, sql ); } else if ( INTEGRITY_VIOLATION_CATEGORIES.contains( sqlStateClassCode ) ) { - String constraintName = getViolatedConstraintName( sqlException ); + String constraintName = extracter.extractConstraintName( sqlException ); return new ConstraintViolationException( message, sqlException, sql, constraintName ); } else if ( CONNECTION_CATEGORIES.contains( sqlStateClassCode ) ) { @@ -84,9 +76,6 @@ else if ( DATA_CATEGORIES.contains( sqlStateClassCode ) ) { return new DataException( message, sqlException, sql ); } - else if ( TRANSACTION_ROLLBACK_CATEGORIES.contains( sqlStateClassCode ) ) { - return new TransactionRollbackException( message, sqlException, sql ); - } } if ( "40001".equals( sqlState ) ) { Deleted: core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateExceptionConverterJDBC4.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateExceptionConverterJDBC4.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/exception/SQLStateExceptionConverterJDBC4.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,87 +0,0 @@ -// $Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.exception; - -import org.hibernate.JDBCException; - -import java.sql.SQLException; - -/** - * A SQLExceptionConverter implementation which performs converion based on - * the underlying SQLState. Interpretation of a SQL error based on SQLState - * is not nearly as accurate as using the ErrorCode (which is, however, vendor- - * specific). Use of a ErrorCode-based converter should be preferred approach - * for converting/interpreting SQLExceptions. - * - * @author Gail Badner - */ -public class SQLStateExceptionConverterJDBC4 extends SQLStateConverter { - - public SQLStateExceptionConverterJDBC4(ViolatedConstraintNameExtracter extracter) { - super( extracter ); - } - - /** - * Convert the given SQLException into Hibernate's JDBCException hierarchy. - * - * @param sqlException The SQLException to be converted. - * @param message An optional error message. - * @param sql Optionally, the sql being performed when the exception occurred. - * @return The resulting JDBCException. - */ - public JDBCException convert(SQLException sqlException, String message, String sql) { - JDBCException jdbcException = super.convert( sqlException, message, sql ); - if ( !( jdbcException instanceof GenericJDBCException) ) { - return jdbcException; - } - - try { - if ( Class.forName( "java.sql.SQLIntegrityConstraintViolationException" ).isInstance( sqlException ) ) { - String constraintName = getViolatedConstraintName( sqlException ); - return new ConstraintViolationException( message, sqlException, sql, constraintName ); - } - else if ( Class.forName( "java.sql.SQLTransactionRollbackException" ).isInstance( sqlException ) ) { - return new TransactionRollbackException( message, sqlException, sql ); - } - else if ( Class.forName( "java.sql.SQLClientInfoException" ).isInstance( sqlException ) || - Class.forName( "java.sql.SQLInvalidAuthorizationSpecException" ).isInstance( sqlException ) || - Class.forName( "java.sql.SQLNonTransientConnectionException" ).isInstance( sqlException ) || - Class.forName( "java.sql.SQLTransientConnectionException" ).isInstance( sqlException ) ) { - return new JDBCConnectionException( message, sqlException, sql ); - } - else if ( Class.forName( "java.sql.SQLSyntaxErrorException" ).isInstance( sqlException ) ) { - return new SQLGrammarException( message, sqlException, sql ); - } - else if ( Class.forName( "java.sql.SQLDataException" ).isInstance( sqlException ) || - Class.forName( "javax.sql.rowset.serial.SerialException" ).isInstance( sqlException ) ) { - return new DataException( message, sqlException, sql ); - } - } - catch ( ClassNotFoundException e ) { - // log because either config is messed up or there's a typo in a class name - } - return jdbcException; - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/src/org/hibernate/exception/TransactionRollbackException.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/exception/TransactionRollbackException.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/exception/TransactionRollbackException.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,59 +0,0 @@ -// $Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.exception; - -import org.hibernate.JDBCException; - -import java.sql.SQLException; - -/** - * Implementation of JDBCException that indicates that the current statement - * was automatically rolled back by the database becuase of deadlock or other - * transaction serialization failures. - * - * @author Gail Badner - */ -public class TransactionRollbackException extends JDBCException { - /** - * Constructor for TransactionRollbackException. - * - * @param message Optional message. - * @param root The underlying exception. - */ - public TransactionRollbackException(String message, SQLException root) { - super( message, root ); - } - - /** - * Constructor for TransactionRollbackException. - * - * @param message Optional message. - * @param root The underlying exception. - * @param sql the SQL statement involved in the exception. - */ - public TransactionRollbackException(String message, SQLException root, String sql) { - super( message, root, sql ); - } -} \ No newline at end of file Modified: core/branches/Branch_3_2/src/org/hibernate/jdbc/ColumnNameCache.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/jdbc/ColumnNameCache.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/jdbc/ColumnNameCache.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -25,7 +25,6 @@ package org.hibernate.jdbc; import java.sql.SQLException; -import java.sql.ResultSet; import java.util.HashMap; import java.util.Map; @@ -43,13 +42,13 @@ this.columnNameToIndexCache = new HashMap( columnCount ); } - public int getIndexForColumnName(String columnName, ResultSet rs) throws SQLException { + public int getIndexForColumnName(String columnName, ResultSetWrapper rs)throws SQLException { Integer cached = ( Integer ) columnNameToIndexCache.get( columnName ); if ( cached != null ) { return cached.intValue(); } else { - int index = rs.findColumn( columnName ); + int index = rs.getTarget().findColumn( columnName ); columnNameToIndexCache.put( columnName, new Integer(index) ); return index; } Added: core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapper.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapper.java (rev 0) +++ core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapper.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -0,0 +1,642 @@ +// $Id$ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Middleware LLC. + * + * 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, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY 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 + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.jdbc; + +import java.io.InputStream; +import java.io.Reader; +import java.math.BigDecimal; +import java.net.URL; +import java.sql.Array; +import java.sql.Blob; +import java.sql.Clob; +import java.sql.Date; +import java.sql.Ref; +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; +import java.sql.SQLException; +import java.sql.SQLWarning; +import java.sql.Statement; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; +import java.util.Map; + +/** + * A ResultSet delegate, responsible for locally caching the columnName-to-columnIndex + * resolution that has been found to be inefficient in a few vendor's drivers (i.e., Oracle + * and Postgres). + * + * @author Steve Ebersole + */ +public class ResultSetWrapper implements ResultSet { + + private ResultSet rs; + private ColumnNameCache columnNameCache; + + public ResultSetWrapper(ResultSet resultSet, ColumnNameCache columnNameCache) { + this.rs = resultSet; + this.columnNameCache = columnNameCache; + } + + /*package*/ ResultSet getTarget() { + return rs; + } + + + // ResultSet impl ("overridden") ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + /** + * Overridden version to utilize local caching of the column indexes by name + * to improve performance for those drivers which are known to not support + * such caching by themselves. + * <p/> + * This implementation performs the caching based on the upper case version + * of the given column name. + * + * @param columnName The column name to resolve into an index. + * @return The column index corresponding to the given column name. + * @throws SQLException - if the ResultSet object does not contain + * columnName or a database access error occurs + */ + public int findColumn(String columnName) throws SQLException { + return columnNameCache.getIndexForColumnName( columnName, this ); + } + + public Array getArray(String colName) throws SQLException { + return rs.getArray( findColumn(colName) ); + } + + public void updateArray(String columnName, Array x) throws SQLException { + rs.updateArray( findColumn(columnName), x ); + } + + public InputStream getAsciiStream(String columnName) throws SQLException { + return rs.getAsciiStream( findColumn(columnName) ); + } + + public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException { + rs.updateAsciiStream( findColumn(columnName), x, length ); + } + + public BigDecimal getBigDecimal(String columnName) throws SQLException { + return rs.getBigDecimal( findColumn(columnName) ); + } + + public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { + return rs.getBigDecimal( findColumn(columnName), scale ); + } + + public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException { + rs.updateBigDecimal( findColumn(columnName), x ); + } + + public InputStream getBinaryStream(String columnName) throws SQLException { + return rs.getBinaryStream( findColumn(columnName) ); + } + + public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException { + rs.updateBinaryStream( findColumn(columnName), x, length ); + } + + public Blob getBlob(String columnName) throws SQLException { + return rs.getBlob( findColumn(columnName) ); + } + + public void updateBlob(String columnName, Blob x) throws SQLException { + rs.updateBlob( findColumn(columnName), x ); + } + + public boolean getBoolean(String columnName) throws SQLException { + return rs.getBoolean( findColumn(columnName) ); + } + + public void updateBoolean(String columnName, boolean x) throws SQLException { + rs.updateBoolean( findColumn(columnName), x ); + } + + public byte getByte(String columnName) throws SQLException { + return rs.getByte( findColumn(columnName) ); + } + + public void updateByte(String columnName, byte x) throws SQLException { + rs.updateByte( findColumn(columnName), x ); + } + + public byte[] getBytes(String columnName) throws SQLException { + return rs.getBytes( findColumn(columnName) ); + } + + public void updateBytes(String columnName, byte[] x) throws SQLException { + rs.updateBytes( findColumn(columnName), x ); + } + + public Reader getCharacterStream(String columnName) throws SQLException { + return rs.getCharacterStream( findColumn(columnName) ); + } + + public void updateCharacterStream(String columnName, Reader x, int length) throws SQLException { + rs.updateCharacterStream( findColumn(columnName), x, length ); + } + + public Clob getClob(String columnName) throws SQLException { + return rs.getClob( findColumn(columnName) ); + } + + public void updateClob(String columnName, Clob x) throws SQLException { + rs.updateClob( findColumn(columnName), x ); + } + + public Date getDate(String columnName) throws SQLException { + return rs.getDate( findColumn(columnName) ); + } + + public Date getDate(String columnName, Calendar cal) throws SQLException { + return rs.getDate( findColumn(columnName), cal ); + } + + public void updateDate(String columnName, Date x) throws SQLException { + rs.updateDate( findColumn(columnName), x ); + } + + public double getDouble(String columnName) throws SQLException { + return rs.getDouble( findColumn(columnName) ); + } + + public void updateDouble(String columnName, double x) throws SQLException { + rs.updateDouble( findColumn(columnName), x ); + } + + public float getFloat(String columnName) throws SQLException { + return rs.getFloat( findColumn(columnName) ); + } + + public void updateFloat(String columnName, float x) throws SQLException { + rs.updateFloat( findColumn(columnName), x ); + } + + public int getInt(String columnName) throws SQLException { + return rs.getInt( findColumn(columnName) ); + } + + public void updateInt(String columnName, int x) throws SQLException { + rs.updateInt( findColumn(columnName), x ); + } + + public long getLong(String columnName) throws SQLException { + return rs.getLong( findColumn(columnName) ); + } + + public void updateLong(String columnName, long x) throws SQLException { + rs.updateLong( findColumn(columnName), x ); + } + + public Object getObject(String columnName) throws SQLException { + return rs.getObject( findColumn(columnName) ); + } + + public Object getObject(String columnName, Map map) throws SQLException { + return rs.getObject( findColumn(columnName), map ); + } + + public void updateObject(String columnName, Object x) throws SQLException { + rs.updateObject( findColumn(columnName), x ); + } + + public void updateObject(String columnName, Object x, int scale) throws SQLException { + rs.updateObject( findColumn(columnName), x, scale ); + } + + public Ref getRef(String columnName) throws SQLException { + return rs.getRef( findColumn(columnName) ); + } + + public void updateRef(String columnName, Ref x) throws SQLException { + rs.updateRef( findColumn(columnName), x ); + } + + public short getShort(String columnName) throws SQLException { + return rs.getShort( findColumn(columnName) ); + } + + public void updateShort(String columnName, short x) throws SQLException { + rs.updateShort( findColumn(columnName), x ); + } + + public String getString(String columnName) throws SQLException { + return rs.getString( findColumn(columnName) ); + } + + public void updateString(String columnName, String x) throws SQLException { + rs.updateString( findColumn(columnName), x ); + } + + public Time getTime(String columnName) throws SQLException { + return rs.getTime( findColumn(columnName) ); + } + + public Time getTime(String columnName, Calendar cal) throws SQLException { + return rs.getTime( findColumn(columnName), cal ); + } + + public void updateTime(String columnName, Time x) throws SQLException { + rs.updateTime( findColumn(columnName), x ); + } + + public Timestamp getTimestamp(String columnName) throws SQLException { + return rs.getTimestamp( findColumn(columnName) ); + } + + public void updateTimestamp(String columnName, Timestamp x) throws SQLException { + rs.updateTimestamp( findColumn(columnName), x ); + } + + public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException { + return rs.getTimestamp( findColumn(columnName), cal ); + } + + public InputStream getUnicodeStream(String columnName) throws SQLException { + return rs.getUnicodeStream( findColumn(columnName) ); + } + + public URL getURL(String columnName) throws SQLException { + return rs.getURL( findColumn(columnName) ); + } + + public void updateNull(String columnName) throws SQLException { + rs.updateNull( findColumn(columnName) ); + } + + + // ResultSet impl (delegated) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + public int getConcurrency() throws SQLException { + return rs.getConcurrency(); + } + + public int getFetchDirection() throws SQLException { + return rs.getFetchDirection(); + } + + public int getFetchSize() throws SQLException { + return rs.getFetchSize(); + } + + public int getRow() throws SQLException { + return rs.getRow(); + } + + public int getType() throws SQLException { + return rs.getType(); + } + + public void afterLast() throws SQLException { + rs.afterLast(); + } + + public void beforeFirst() throws SQLException { + rs.beforeFirst(); + } + + public void cancelRowUpdates() throws SQLException { + rs.cancelRowUpdates(); + } + + public void clearWarnings() throws SQLException { + rs.clearWarnings(); + } + + public void close() throws SQLException { + rs.close(); + } + + public void deleteRow() throws SQLException { + rs.deleteRow(); + } + + public void insertRow() throws SQLException { + rs.insertRow(); + } + + public void moveToCurrentRow() throws SQLException { + rs.moveToCurrentRow(); + } + + public void moveToInsertRow() throws SQLException { + rs.moveToInsertRow(); + } + + public void refreshRow() throws SQLException { + rs.refreshRow(); + } + + public void updateRow() throws SQLException { + rs.updateRow(); + } + + public boolean first() throws SQLException { + return rs.first(); + } + + public boolean isAfterLast() throws SQLException { + return rs.isAfterLast(); + } + + public boolean isBeforeFirst() throws SQLException { + return rs.isBeforeFirst(); + } + + public boolean isFirst() throws SQLException { + return rs.isFirst(); + } + + public boolean isLast() throws SQLException { + return rs.isLast(); + } + + public boolean last() throws SQLException { + return rs.last(); + } + + public boolean next() throws SQLException { + return rs.next(); + } + + public boolean previous() throws SQLException { + return rs.previous(); + } + + public boolean rowDeleted() throws SQLException { + return rs.rowDeleted(); + } + + public boolean rowInserted() throws SQLException { + return rs.rowInserted(); + } + + public boolean rowUpdated() throws SQLException { + return rs.rowUpdated(); + } + + public boolean wasNull() throws SQLException { + return rs.wasNull(); + } + + public byte getByte(int columnIndex) throws SQLException { + return rs.getByte(columnIndex); + } + + public double getDouble(int columnIndex) throws SQLException { + return rs.getDouble(columnIndex); + } + + public float getFloat(int columnIndex) throws SQLException { + return rs.getFloat(columnIndex); + } + + public int getInt(int columnIndex) throws SQLException { + return rs.getInt(columnIndex); + } + + public long getLong(int columnIndex) throws SQLException { + return rs.getLong(columnIndex); + } + + public short getShort(int columnIndex) throws SQLException { + return rs.getShort(columnIndex); + } + + public void setFetchDirection(int direction) throws SQLException { + rs.setFetchDirection(direction); + } + + public void setFetchSize(int rows) throws SQLException { + rs.setFetchSize(rows); + } + + public void updateNull(int columnIndex) throws SQLException { + rs.updateNull(columnIndex); + } + + public boolean absolute(int row) throws SQLException { + return rs.absolute(row); + } + + public boolean getBoolean(int columnIndex) throws SQLException { + return rs.getBoolean(columnIndex); + } + + public boolean relative(int rows) throws SQLException { + return rs.relative(rows); + } + + public byte[] getBytes(int columnIndex) throws SQLException { + return rs.getBytes(columnIndex); + } + + public void updateByte(int columnIndex, byte x) throws SQLException { + rs.updateByte(columnIndex, x); + } + + public void updateDouble(int columnIndex, double x) throws SQLException { + rs.updateDouble(columnIndex, x); + } + + public void updateFloat(int columnIndex, float x) throws SQLException { + rs.updateFloat(columnIndex, x); + } + + public void updateInt(int columnIndex, int x) throws SQLException { + rs.updateInt(columnIndex, x); + } + + public void updateLong(int columnIndex, long x) throws SQLException { + rs.updateLong(columnIndex, x); + } + + public void updateShort(int columnIndex, short x) throws SQLException { + rs.updateShort(columnIndex, x); + } + + public void updateBoolean(int columnIndex, boolean x) throws SQLException { + rs.updateBoolean(columnIndex, x); + } + + public void updateBytes(int columnIndex, byte[] x) throws SQLException { + rs.updateBytes(columnIndex, x); + } + + public InputStream getAsciiStream(int columnIndex) throws SQLException { + return rs.getAsciiStream(columnIndex); + } + + public InputStream getBinaryStream(int columnIndex) throws SQLException { + return rs.getBinaryStream(columnIndex); + } + + public InputStream getUnicodeStream(int columnIndex) throws SQLException { + return rs.getUnicodeStream(columnIndex); + } + + public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException { + rs.updateAsciiStream(columnIndex, x, length); + } + + public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException { + rs.updateBinaryStream(columnIndex, x, length); + } + + public Reader getCharacterStream(int columnIndex) throws SQLException { + return rs.getCharacterStream(columnIndex); + } + + public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException { + rs.updateCharacterStream(columnIndex, x, length); + } + + public Object getObject(int columnIndex) throws SQLException { + return rs.getObject(columnIndex); + } + + public void updateObject(int columnIndex, Object x) throws SQLException { + rs.updateObject(columnIndex, x); + } + + public void updateObject(int columnIndex, Object x, int scale) throws SQLException { + rs.updateObject(columnIndex, x, scale); + } + + public String getCursorName() throws SQLException { + return rs.getCursorName(); + } + + public String getString(int columnIndex) throws SQLException { + return rs.getString(columnIndex); + } + + public void updateString(int columnIndex, String x) throws SQLException { + rs.updateString(columnIndex, x); + } + + public BigDecimal getBigDecimal(int columnIndex) throws SQLException { + return rs.getBigDecimal(columnIndex); + } + + public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { + return rs.getBigDecimal(columnIndex, scale); + } + + public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { + rs.updateBigDecimal(columnIndex, x); + } + + public URL getURL(int columnIndex) throws SQLException { + return rs.getURL(columnIndex); + } + + public Array getArray(int columnIndex) throws SQLException { + return rs.getArray(columnIndex); + } + + public void updateArray(int columnIndex, Array x) throws SQLException { + rs.updateArray(columnIndex, x); + } + + public Blob getBlob(int columnIndex) throws SQLException { + return rs.getBlob(columnIndex); + } + + public void updateBlob(int columnIndex, Blob x) throws SQLException { + rs.updateBlob(columnIndex, x); + } + + public Clob getClob(int columnIndex) throws SQLException { + return rs.getClob(columnIndex); + } + + public void updateClob(int columnIndex, Clob x) throws SQLException { + rs.updateClob(columnIndex, x); + } + + public Date getDate(int columnIndex) throws SQLException { + return rs.getDate(columnIndex); + } + + public void updateDate(int columnIndex, Date x) throws SQLException { + rs.updateDate(columnIndex, x); + } + + public Ref getRef(int columnIndex) throws SQLException { + return rs.getRef(columnIndex); + } + + public void updateRef(int columnIndex, Ref x) throws SQLException { + rs.updateRef(columnIndex, x); + } + + public ResultSetMetaData getMetaData() throws SQLException { + return rs.getMetaData(); + } + + public SQLWarning getWarnings() throws SQLException { + return rs.getWarnings(); + } + + public Statement getStatement() throws SQLException { + return rs.getStatement(); + } + + public Time getTime(int columnIndex) throws SQLException { + return rs.getTime(columnIndex); + } + + public void updateTime(int columnIndex, Time x) throws SQLException { + rs.updateTime(columnIndex, x); + } + + public Timestamp getTimestamp(int columnIndex) throws SQLException { + return rs.getTimestamp(columnIndex); + } + + public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException { + rs.updateTimestamp(columnIndex, x); + } + + public Object getObject(int columnIndex, Map map) throws SQLException { + return rs.getObject( columnIndex, map ); + } + + public Date getDate(int columnIndex, Calendar cal) throws SQLException { + return rs.getDate(columnIndex, cal); + } + + public Time getTime(int columnIndex, Calendar cal) throws SQLException { + return rs.getTime(columnIndex, cal); + } + + public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException { + return rs.getTimestamp(columnIndex, cal); + } +} + Deleted: core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapperProxy.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapperProxy.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/jdbc/ResultSetWrapperProxy.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,170 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.jdbc; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.lang.reflect.InvocationTargetException; -import java.sql.ResultSet; -import java.sql.SQLException; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -import org.hibernate.util.JDBCExceptionReporter; - -/** - * A proxy for a ResultSet delegate, responsible for locally caching the - * columnName-to-columnIndex resolution that has been found to be inefficient - * in a few vendor's drivers (i.e., Oracle and Postgres). - * - * @author Gail Badner - */ -public class ResultSetWrapperProxy implements InvocationHandler { - - private static final Class[] PROXY_INTERFACES = new Class[] { ResultSet.class }; - private static final Log log = LogFactory.getLog( ResultSetWrapperProxy.class ); - - private final ResultSet rs; - private ColumnNameCache columnNameCache; - - /** - * Generates a proxy wrapping the ResultSet. - * - * @param resultSet The resultSet to wrap. - * @param columnNameCache The cache storing data for converting column names to column indexes. - * @return The generated proxy. - */ - public static ResultSet generateProxy(ResultSet resultSet, ColumnNameCache columnNameCache) { - return ( ResultSet ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new ResultSetWrapperProxy( resultSet, columnNameCache ) - ); - } - - private ResultSetWrapperProxy(ResultSet resultSet, ColumnNameCache columnNameCache) { - this.rs = resultSet; - this.columnNameCache = columnNameCache; - } - - /** - * Overridden version to utilize local caching of the column indexes by name - * to improve performance for those drivers which are known to not support - * such caching by themselves. - * <p/> - * This implementation performs the caching based on the upper case version - * of the given column name. - * - * @param columnName The column name to resolve into an index. - * @return The column index corresponding to the given column name. - * @throws java.sql.SQLException - if the ResultSet object does not contain - * columnName or a database access error occurs - */ - public int findColumn(String columnName) throws SQLException { - return columnNameCache.getIndexForColumnName( columnName, rs ); - } - - /** - * {@inheritDoc} - */ - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ( isFirstArgColumnLabel( method, args ) ) { - try { - int columnIndex = findColumn( ( String ) args[0] ); - return invokeMethod( getMethodUsingColumnIndex( method ), getArgsUsingColumnIndex( args, columnIndex ) ); - } - catch ( SQLException ex ) { - StringBuffer buf = new StringBuffer() - .append( "Exception getting column index for column: [" ) - .append( args[0] ) - .append( "].\nReverting to using: [" ) - .append( args[ 0 ] ) - .append( "] as first argument for method: [" ) - .append( method ) - .append( "]" ); - JDBCExceptionReporter.logExceptions( ex, buf.toString() ); - } - catch ( NoSuchMethodException ex ) { - StringBuffer buf = new StringBuffer() - .append( "Exception switching from method: [" ) - .append( method ) - .append( "] to a method using the column index. Reverting to using: [" ) - .append( method ) - .append( "]" ); - if ( log.isWarnEnabled() ) { - log.warn( buf.toString() ); - } - } - } - return invokeMethod( method, args ); - } - - private boolean isFirstArgColumnLabel(Method method, Object args[]) { - return method.getParameterTypes().length > 0 && - method.getParameterTypes()[ 0 ].equals( String.class ) && - args.length == method.getParameterTypes().length && - String.class.isInstance( args[ 0 ] ) && - ( method.getName().startsWith( "get" ) || method.getName().startsWith( "update" ) ); - } - - private Method getMethodUsingColumnIndex(Method method) throws NoSuchMethodException { - Class actualParameterTypes[] = new Class[ method.getParameterTypes().length ]; - actualParameterTypes[0] = int.class; - System.arraycopy( method.getParameterTypes(), 1, actualParameterTypes, 1, method.getParameterTypes().length - 1 ); - return method.getDeclaringClass().getMethod( method.getName(), actualParameterTypes ); - } - - private Object[] getArgsUsingColumnIndex( Object[] args, int columnIndex ) { - Object actualArgs[] = new Object[ args.length ]; - actualArgs[0] = new Integer( columnIndex ); - System.arraycopy( args, 1, actualArgs, 1, args.length - 1 ); - return actualArgs; - } - - private Object invokeMethod( Method method, Object args[] ) throws Throwable { - try { - return method.invoke( rs, args ); - } - catch( InvocationTargetException e ) { - throw e.getTargetException(); - } - } - - /** - * Determines the appropriate class loader to which the generated proxy - * should be scoped. - * - * @return The class loader appropriate for proxy construction. - */ - public static ClassLoader getProxyClassLoader() { - ClassLoader cl = Thread.currentThread().getContextClassLoader(); - if ( cl == null ) { - cl = ResultSet.class.getClassLoader(); - } - return cl; - } -} \ No newline at end of file Modified: core/branches/Branch_3_2/src/org/hibernate/loader/Loader.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/loader/Loader.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/loader/Loader.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -48,7 +48,7 @@ import org.hibernate.impl.FetchingScrollableResultsImpl; import org.hibernate.impl.ScrollableResultsImpl; import org.hibernate.jdbc.ColumnNameCache; -import org.hibernate.jdbc.ResultSetWrapperProxy; +import org.hibernate.jdbc.ResultSetWrapper; import org.hibernate.persister.collection.CollectionPersister; import org.hibernate.persister.entity.EntityPersister; import org.hibernate.persister.entity.Loadable; @@ -1818,7 +1818,7 @@ if ( session.getFactory().getSettings().isWrapResultSetsEnabled() ) { try { log.debug("Wrapping result set [" + rs + "]"); - return ResultSetWrapperProxy.generateProxy( rs, retreiveColumnNameToIndexCache( rs ) ); + return new ResultSetWrapper( rs, retreiveColumnNameToIndexCache( rs ) ); } catch(SQLException e) { log.info("Error wrapping result set", e); Modified: core/branches/Branch_3_2/src/org/hibernate/lob/BlobImpl.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/BlobImpl.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/BlobImpl.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -25,10 +25,113 @@ */ package org.hibernate.lob; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; import java.sql.Blob; +import java.sql.SQLException; /** + * A dummy implementation of <tt>java.sql.Blob</tt> that + * may be used to insert new data into a BLOB. * @author Gavin King */ -public interface BlobImpl extends Blob { -} \ No newline at end of file +public class BlobImpl implements Blob { + + private InputStream stream; + private int length; + private boolean needsReset = false; + + public BlobImpl(byte[] bytes) { + this.stream = new ByteArrayInputStream(bytes); + this.length = bytes.length; + } + + public BlobImpl(InputStream stream, int length) { + this.stream = stream; + this.length = length; + } + + /** + * @see java.sql.Blob#length() + */ + public long length() throws SQLException { + return length; + } + + /** + * @see java.sql.Blob#truncate(long) + */ + public void truncate(long pos) throws SQLException { + excep(); + } + + /** + * @see java.sql.Blob#getBytes(long, int) + */ + public byte[] getBytes(long pos, int len) throws SQLException { + excep(); return null; + } + + /** + * @see java.sql.Blob#setBytes(long, byte[]) + */ + public int setBytes(long pos, byte[] bytes) throws SQLException { + excep(); return 0; + } + + /** + * @see java.sql.Blob#setBytes(long, byte[], int, int) + */ + public int setBytes(long pos, byte[] bytes, int i, int j) + throws SQLException { + excep(); return 0; + } + + /** + * @see java.sql.Blob#position(byte[], long) + */ + public long position(byte[] bytes, long pos) throws SQLException { + excep(); return 0; + } + + /** + * @see java.sql.Blob#getBinaryStream() + */ + public InputStream getBinaryStream() throws SQLException { + try { + if (needsReset) stream.reset(); + } + catch (IOException ioe) { + throw new SQLException("could not reset reader"); + } + needsReset = true; + return stream; + } + + /** + * @see java.sql.Blob#setBinaryStream(long) + */ + public OutputStream setBinaryStream(long pos) throws SQLException { + excep(); return null; + } + + /** + * @see java.sql.Blob#position(Blob, long) + */ + public long position(Blob blob, long pos) throws SQLException { + excep(); return 0; + } + + private static void excep() { + throw new UnsupportedOperationException("Blob may not be manipulated from creating session"); + } + +} + + + + + + Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/BlobImplProxy.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/BlobImplProxy.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/BlobImplProxy.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,148 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.lob; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.sql.Blob; -import java.sql.SQLException; -import java.io.InputStream; -import java.io.ByteArrayInputStream; -import java.io.IOException; - -/** - * A proxy for a dummy implementation of <tt>java.sql.Blob</tt> that - * is used to insert new data into a Blob when the Connection is not used - * for creating new Blobs. - * - * This implementation provides minimal functionality for creating a - * new Blob. The only operations that are supported are {@link #length()} - * and {@link #getBinaryStream()}. All other operations will throw - * UnsupportedOperationException. - * - * The proxy extends BlobImpl so that it can be distinguished from a Blob. - * - * @author Gail Badner - */ -public class BlobImplProxy implements InvocationHandler { - - private static final Class[] PROXY_INTERFACES = new Class[] { BlobImpl.class }; - - private InputStream stream; - private int length; - private boolean needsReset = false; - - /** - * Generates a BlobImpl proxy using byte data. - * - * @param bytes The data to be created as a Blob. - * @return The generated proxy. - */ - public static Blob generateProxy(byte[] bytes) { - return ( Blob ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new BlobImplProxy( bytes ) - ); - } - - /** - * Generates a BlobImpl proxy using a given number of bytes from an InputStream. - * - * @param stream The input stream of bytes to be created as a Blob. - * @param length The number of bytes from stream to be written to the Blob. - * @return The generated proxy. - */ - public static Blob generateProxy(InputStream stream, int length) { - return ( Blob ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new BlobImplProxy( stream, length ) - ); - } - - private BlobImplProxy(byte[] bytes) { - this.stream = new ByteArrayInputStream(bytes); - this.length = bytes.length; - } - - private BlobImplProxy(InputStream stream, int length) { - this.stream = stream; - this.length = length; - } - - /** - * @see java.sql.Blob#length() - */ - public long length() throws SQLException { - return length; - } - - /** - * @see java.sql.Blob#getBinaryStream() - */ - public InputStream getBinaryStream() throws SQLException { - try { - if (needsReset) stream.reset(); - } - catch ( IOException ioe) { - throw new SQLException("could not reset reader"); - } - needsReset = true; - return stream; - } - - /** - * {@inheritDoc} - * - * @throws UnsupportedOperationException if any methods other than {@link #length()} - * or {@link #getBinaryStream} are invoked. - */ - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ( "length".equals( method.getName() ) ) { - return new Long( length() ); - } - if ( "getBinaryStream".equals( method.getName() ) && method.getParameterTypes().length == 0) { - return getBinaryStream(); - } - throw new UnsupportedOperationException("Blob may not be manipulated from creating session"); - } - - /** - * Determines the appropriate class loader to which the generated proxy - * should be scoped. - * - * @return The class loader appropriate for proxy construction. - */ - public static ClassLoader getProxyClassLoader() { - ClassLoader cl = Thread.currentThread().getContextClassLoader(); - if ( cl == null ) { - cl = BlobImpl.class.getClassLoader(); - } - return cl; - } -} \ No newline at end of file Modified: core/branches/Branch_3_2/src/org/hibernate/lob/ClobImpl.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/ClobImpl.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/ClobImpl.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -25,10 +25,137 @@ */ package org.hibernate.lob; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.Reader; +import java.io.StringReader; +import java.io.Writer; import java.sql.Clob; +import java.sql.SQLException; /** + * A dummy implementation of <tt>java.sql.Clob</tt> that + * may be used to insert new data into a CLOB. * @author Gavin King */ -public interface ClobImpl extends Clob { -} \ No newline at end of file +public class ClobImpl implements Clob { + + private Reader reader; + private int length; + private boolean needsReset = false; + + public ClobImpl(String string) { + reader = new StringReader(string); + length = string.length(); + } + + public ClobImpl(Reader reader, int length) { + this.reader = reader; + this.length = length; + } + + /** + * @see java.sql.Clob#length() + */ + public long length() throws SQLException { + return length; + } + + /** + * @see java.sql.Clob#truncate(long) + */ + public void truncate(long pos) throws SQLException { + excep(); + } + + /** + * @see java.sql.Clob#getAsciiStream() + */ + public InputStream getAsciiStream() throws SQLException { + try { + if (needsReset) reader.reset(); + } + catch (IOException ioe) { + throw new SQLException("could not reset reader"); + } + needsReset = true; + return new ReaderInputStream(reader); + } + + /** + * @see java.sql.Clob#setAsciiStream(long) + */ + public OutputStream setAsciiStream(long pos) throws SQLException { + excep(); return null; + } + + /** + * @see java.sql.Clob#getCharacterStream() + */ + public Reader getCharacterStream() throws SQLException { + try { + if (needsReset) reader.reset(); + } + catch (IOException ioe) { + throw new SQLException("could not reset reader"); + } + needsReset = true; + return reader; + } + + /** + * @see java.sql.Clob#setCharacterStream(long) + */ + public Writer setCharacterStream(long pos) throws SQLException { + excep(); return null; + } + + /** + * @see java.sql.Clob#getSubString(long, int) + */ + public String getSubString(long pos, int len) throws SQLException { + excep(); return null; + } + + /** + * @see java.sql.Clob#setString(long, String) + */ + public int setString(long pos, String string) throws SQLException { + excep(); return 0; + } + + /** + * @see java.sql.Clob#setString(long, String, int, int) + */ + public int setString(long pos, String string, int i, int j) + throws SQLException { + excep(); return 0; + } + + /** + * @see java.sql.Clob#position(String, long) + */ + public long position(String string, long pos) throws SQLException { + excep(); return 0; + } + + /** + * @see java.sql.Clob#position(Clob, long) + */ + public long position(Clob colb, long pos) throws SQLException { + excep(); return 0; + } + + + private static void excep() { + throw new UnsupportedOperationException("Blob may not be manipulated from creating session"); + } + +} + + + + + + Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/ClobImplProxy.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/ClobImplProxy.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/ClobImplProxy.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,165 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.lob; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.sql.SQLException; -import java.sql.Clob; -import java.io.InputStream; -import java.io.IOException; -import java.io.Reader; -import java.io.StringReader; - -/** - * A proxy for a dummy implementation of <tt>java.sql.Clob</tt> that - * is used to insert new data into a Clob when the Connection is not used - * for creating new Clobs. - * - * This implementation provides minimal functionality for creating a - * new Clob. The only operations that are supported are {@link #length()}, - * {@link #getAsciiStream()}, and {@link #getCharacterStream()}. All other - * operations will throw UnsupportedOperationException. - * - * The proxy extends ClobImpl so that it can be distinguished from a Clob. - * - * @author Gail Badner - */ -public class ClobImplProxy implements InvocationHandler { - - private static final Class[] PROXY_INTERFACES = new Class[] { ClobImpl.class }; - - private Reader reader; - private int length; - private boolean needsReset = false; - - /** - * Generates a BlobImpl proxy using a String. - * - * @param string The data to be created as a Clob. - * @return The generated proxy. - */ - public static Clob generateProxy(String string) { - return ( Clob ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new ClobImplProxy( string ) - ); - } - - /** - * Generates a ClobImpl proxy using a given number of characters from a Reader. - * - * @param reader The Reader for character data to be created as a Clob. - * @param length The number of characters from Reader to be written to the Clob. - * @return The generated proxy. - */ - public static Clob generateProxy(Reader reader, int length) { - return ( Clob ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new ClobImplProxy( reader, length ) - ); - } - - private ClobImplProxy(String string) { - reader = new StringReader(string); - length = string.length(); - } - - private ClobImplProxy(Reader reader, int length) { - this.reader = reader; - this.length = length; - } - - /** - * @see java.sql.Clob#length() - */ - public long length() throws SQLException { - return length; - } - - /** - * @see java.sql.Clob#getAsciiStream() - */ - public InputStream getAsciiStream() throws SQLException { - reset(); - return new ReaderInputStream(reader); - } - - /** - * @see java.sql.Clob#getCharacterStream() - */ - public Reader getCharacterStream() throws SQLException { - reset(); - return reader; - } - - /** - * {@inheritDoc} - * - * @throws UnsupportedOperationException if any methods other than {@link #length()}, - * {@link #getAsciiStream()}, or {@link #getCharacterStream()} are invoked. - */ - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ( "length".equals( method.getName() ) ) { - return new Long( length() ); - } - if ( "getAsciiStream".equals( method.getName() ) ) { - return getAsciiStream(); - } - if ( "getCharacterStream".equals( method.getName() ) ) { - return getCharacterStream(); - } - throw new UnsupportedOperationException("Clob may not be manipulated from creating session"); - } - - /** - * Determines the appropriate class loader to which the generated proxy - * should be scoped. - * - * @return The class loader appropriate for proxy construction. - */ - public static ClassLoader getProxyClassLoader() { - ClassLoader cl = Thread.currentThread().getContextClassLoader(); - if ( cl == null ) { - cl = ClobImpl.class.getClassLoader(); - } - return cl; - } - - - private void reset() throws SQLException { - try { - if (needsReset) reader.reset(); - } - catch (IOException ioe) { - throw new SQLException("could not reset reader"); - } - needsReset = true; - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/LobCreator.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/LobCreator.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/LobCreator.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,96 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.lob; - -import java.sql.Clob; -import java.sql.Blob; -import java.io.InputStream; -import java.io.Reader; -import java.io.IOException; - -import org.hibernate.HibernateException; - -/** - * This interface defines the API for creating Blobs and Clobs. - * - * @author Gail Badner - */ -public interface LobCreator { - - /** - * Returns a Blob object representing a SQL BLOB created from the given array of bytes. - * - * @param bytes The array of bytes to be written to this BLOB object. - * @return the created Blob - * @throws HibernateException if the Blob could not be created - */ - Blob createBlob(byte[] bytes) throws HibernateException; - - /** - * Returns a Blob object representing a SQL BLOB created from the given number of bytes - * from an InputStream. - * - * @param is The input stream of bytes to be written to this BLOB object. - * @param length The number of bytes from stream to be written to this BLOB object. - * @return the created Blob - * @throws HibernateException if the Blob could not be created - * @throws IOException if an I/O error occurs - */ - Blob createBlob(InputStream is, int length) throws HibernateException, IOException; - - - /** - * Returns a Blob object representing a SQL BLOB created from the available (is.available()) - * number of bytes from an InputStream. - * - * @param is The input stream of bytes to be written to this BLOB object. - * @return the created Blob - * @throws HibernateException if the Blob could not be created - * @throws IOException if an I/O error occurs - */ - Blob createBlob(InputStream is) throws HibernateException, IOException; - - /** - * Returns a Clob object representing a SQL CLOB created from the given String. - * - * @param string The String to be written to this CLOB object - * @throws HibernateException if the Clob could not be created - * @throws HibernateException - */ - Clob createClob(String string) throws HibernateException; - - /** - * Returns a Clob object representing a SQL CLOB created from the given number of - * characters from a character stream. - * - * @param reader The character stream to be written to this CLOB object. - * @param length The number of characters from reader to be written to this CLOB object. - * @return the created Clob - * @throws HibernateException if the Clob could not be created - * @throws IOException if an I/O error occurs - */ - Clob createClob(Reader reader, int length) throws HibernateException, IOException; -} \ No newline at end of file Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorFactory.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorFactory.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorFactory.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,75 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.lob; - -import org.hibernate.Session; -import org.hibernate.AssertionFailure; -import org.hibernate.engine.SessionFactoryImplementor; - -/** - * A factory for creating an instance of the appropriate LobCreator implementation. - * - * @author Gail Badner - */ -public class LobCreatorFactory { - - /** - * Creates an instance of a LobCreator that does not use the Connection to create LOBs. - * The returned LobCreator is appropriate for JVM and/or JDBC drivers that support JDBC3, - * but not JDBC4. - * - * @return the LobCreator - */ - public static LobCreator createLobCreator() { - return new LobCreatorImplJDBC3(); - } - - /** - * If the setting for Environment#USE_CONNECTION_FOR_LOB_CREATION is true, then the - * returned LobCreator will use the Connection to create LOBs. If it is false, then - * the returned LobCreator will not use the Connection to create LOBs. - * - * If the property is not set, then the returned LobCreator will use the connection to - * create LOBs only if the JVM and JDBC driver support this JDBC4 functionality. - * - * (@see Environment#USE_CONNECTION_FOR_LOB_CREATION) - * - * @param session The session. - * @return the LobCreator - */ - public static LobCreator createLobCreator(Session session) { - if ( session == null ) { - throw new AssertionFailure("session is null; use LobCreatorFactory.createLobCreator() instead."); - } - SessionFactoryImplementor sfi = ( SessionFactoryImplementor ) session.getSessionFactory(); - if ( sfi.getSettings().isUseConnectionForLobCreationEnabled() ) { - return new LobCreatorImplJDBC4( session ); - } - else { - return new LobCreatorImplJDBC3(); - } - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC3.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC3.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC3.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,79 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.lob; - -import java.sql.Blob; -import java.sql.Clob; -import java.io.InputStream; -import java.io.Reader; -import java.io.IOException; - -/** - * A LobCreator implementation that can be used with JVMs and JDBC drivers that support JDBC3. - * - * @author Gail Badner - */ -public class LobCreatorImplJDBC3 implements LobCreator { - - /* package */ - LobCreatorImplJDBC3() { - } - - /** - * {@inheritDoc} - */ - public Blob createBlob(byte[] bytes) { - return SerializableBlobProxy.generateProxy( BlobImplProxy.generateProxy( bytes ) ); - } - - /** - * {@inheritDoc} - */ - public Blob createBlob(InputStream is, int length) { - return SerializableBlobProxy.generateProxy( BlobImplProxy.generateProxy( is, length ) ); - } - - /** - * {@inheritDoc} - */ - public Blob createBlob(InputStream is) throws IOException { - return SerializableBlobProxy.generateProxy( BlobImplProxy.generateProxy( is, is.available() ) ); - } - - /** - * {@inheritDoc} - */ - public Clob createClob(String string) { - return SerializableClobProxy.generateProxy( ClobImplProxy.generateProxy( string ) ); - } - - /** - * {@inheritDoc} - */ - public Clob createClob(Reader reader, int length) { - return SerializableClobProxy.generateProxy( ClobImplProxy.generateProxy( reader, length ) ); - } -} Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC4.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC4.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/LobCreatorImplJDBC4.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,195 +0,0 @@ -// $Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.lob; - -import java.sql.Blob; -import java.sql.Clob; -import java.sql.Connection; -import java.sql.SQLException; -import java.io.InputStream; -import java.io.Reader; -import java.io.OutputStream; -import java.io.Writer; -import java.io.IOException; -import java.lang.reflect.Method; -import java.lang.reflect.InvocationTargetException; -import org.hibernate.Session; -import org.hibernate.HibernateException; -import org.hibernate.cfg.Environment; -import org.hibernate.exception.JDBCExceptionHelper; -import org.hibernate.engine.SessionImplementor; - -/** - * A LobCreator implementation that can be used with JVMs and JDBC drivers that support JDBC4. - * - * @author Gail Badner - */ -public class LobCreatorImplJDBC4 implements LobCreator { - private final SessionImplementor session; - - /* package */ - LobCreatorImplJDBC4(Session session) { - this.session = ( SessionImplementor ) session; - } - - /** - * {@inheritDoc} - */ - public Blob createBlob(byte[] bytes) throws HibernateException { - Blob blob = createBlob(); - try { - blob.setBytes( 1, bytes ); - } - catch ( SQLException e ) { - throw JDBCExceptionHelper.convert( - session.getFactory().getSQLExceptionConverter(), - e, - "Exception invoking adding data to a Blob." - ); - } - return blob; - } - - /** - * {@inheritDoc} - */ - public Blob createBlob(InputStream is, int length) throws HibernateException, IOException { - Blob blob = createBlob(); - try { - OutputStream os = blob.setBinaryStream(1); - byte[] data = new byte[1]; - for ( int i = 0; i < length && is.read( data ) != -1; i++ ) { - os.write( data ); - } - os.flush(); - os.close(); - return blob; - } - catch ( SQLException e ) { - throw JDBCExceptionHelper.convert( - session.getFactory().getSQLExceptionConverter(), - e, - "Exception getting OutputStream to add data to a Blob." - ); - } - } - - /** - * {@inheritDoc} - */ - public Blob createBlob(InputStream is) throws HibernateException, IOException { - return createBlob( is, is.available() ); - } - - /** - * {@inheritDoc} - */ - public Clob createClob(String string) throws HibernateException { - Clob clob = createClob(); - try { - clob.setString( 1, string ); - return clob; - } - catch ( SQLException e ) { - throw JDBCExceptionHelper.convert( - session.getFactory().getSQLExceptionConverter(), - e, - "Exception adding a String to a Clob." - ); - } - } - - /** - * {@inheritDoc} - */ - public Clob createClob(Reader reader, int length) throws HibernateException, IOException { - Clob clob = createClob(); - try { - Writer writer = clob.setCharacterStream( 1 ); - char[] data = new char[1]; - for ( int i = 0; i < length && reader.read( data ) != -1; i++ ) { - writer.write( data ); - } - writer.flush(); - writer.close(); - return clob; - } - catch ( SQLException e ) { - throw JDBCExceptionHelper.convert( - session.getFactory().getSQLExceptionConverter(), - e, - "Exception getting OutputStream to add data to a Clob." - ); - } - } - - private Blob createBlob() { - final String CREATE_BLOB_METHOD_NAME = "createBlob"; - return ( Blob ) invokeConnectionMethod( CREATE_BLOB_METHOD_NAME ); - } - - private Clob createClob() { - final String CREATE_CLOB_METHOD_NAME = "createClob"; - return ( Clob ) invokeConnectionMethod( CREATE_CLOB_METHOD_NAME ); - } - - private Object invokeConnectionMethod(String methodName) throws HibernateException { - Connection connection = session.getJDBCContext().getConnectionManager().getConnection(); - final Object emptyArray[] = { }; - try { - Method method = Connection.class.getMethod( methodName, new Class[0] ); - Object object = method.invoke( connection, emptyArray ); - session.getJDBCContext().getConnectionManager().afterStatement(); - return object; - } - catch ( NoSuchMethodException e ) { - throw new HibernateException( getMethodString( connection, methodName ) + " not supported. Set " + Environment.USE_CONNECTION_FOR_LOB_CREATION + " to false.", e ); - } - catch ( AbstractMethodError e ) { - throw new HibernateException( "Implementation of " + getMethodString( connection, methodName ) + " not found. Set " + Environment.USE_CONNECTION_FOR_LOB_CREATION + " to false.", e ); - } - catch ( InvocationTargetException e ) { - if ( e.getTargetException() instanceof SQLException ) { - throw JDBCExceptionHelper.convert( - session.getFactory().getSQLExceptionConverter(), - ( SQLException ) e.getTargetException(), - "Exception invoking " + getMethodString( connection, methodName ) - ); - } - throw new HibernateException( "Exception invoking " + getMethodString( connection, methodName ), e.getTargetException() ); - } - catch ( IllegalAccessException e ) { - throw new HibernateException( "Cannot access " + getMethodString( connection, methodName ), e ); - } - } - - private String getMethodString(Connection connection, String methodName) { - return new StringBuffer() - .append( connection.getClass().getName() ) - .append('.') - .append( methodName ) - .append( "()" ).toString(); - } -} Modified: core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlob.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlob.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlob.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -24,12 +24,66 @@ */ package org.hibernate.lob; +import java.io.InputStream; +import java.io.OutputStream; import java.io.Serializable; import java.sql.Blob; +import java.sql.SQLException; /** * @author Gavin King */ -public interface SerializableBlob extends Serializable, Blob { - public Blob getWrappedBlob(); -} \ No newline at end of file +public class SerializableBlob implements Serializable, Blob { + + private transient final Blob blob; + + public SerializableBlob(Blob blob) { + this.blob = blob; + } + + public Blob getWrappedBlob() { + if ( blob==null ) { + throw new IllegalStateException("Blobs may not be accessed after serialization"); + } + else { + return blob; + } + } + + public long length() throws SQLException { + return getWrappedBlob().length(); + } + + public byte[] getBytes(long pos, int length) throws SQLException { + return getWrappedBlob().getBytes(pos, length); + } + + public InputStream getBinaryStream() throws SQLException { + return getWrappedBlob().getBinaryStream(); + } + + public long position(byte[] pattern, long start) throws SQLException { + return getWrappedBlob().position(pattern, start); + } + + public long position(Blob pattern, long start) throws SQLException { + return getWrappedBlob().position(pattern, start); + } + + public int setBytes(long pos, byte[] bytes) throws SQLException { + return getWrappedBlob().setBytes(pos, bytes); + } + + public int setBytes(long pos, byte[] bytes, int offset, int len) throws SQLException { + return getWrappedBlob().setBytes(pos, bytes, offset, len); + } + + public OutputStream setBinaryStream(long pos) throws SQLException { + return getWrappedBlob().setBinaryStream(pos); + } + + public void truncate(long len) throws SQLException { + getWrappedBlob().truncate(len); + } + +} Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlobProxy.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlobProxy.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/SerializableBlobProxy.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,104 +0,0 @@ -// $Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.lob; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.lang.reflect.InvocationTargetException; -import java.sql.Blob; -import org.hibernate.HibernateException; - -/** - * A proxy for SerializableBlob objects which delegates all Blob methods to - * a wrapped Blob. - * - * @author Gail Badner - */ -public class SerializableBlobProxy implements InvocationHandler { - - private static final Class[] PROXY_INTERFACES = new Class[] { SerializableBlob.class }; - - private transient final Blob blob; - - /** - * Generates a SerializableBlob proxy wrapping the provided Blob object. - * - * @param blob The Blob to wrap. - * @return The generated proxy. - */ - public static Blob generateProxy(Blob blob) { - return ( Blob ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new SerializableBlobProxy( blob ) - ); - } - - private SerializableBlobProxy(Blob blob) { - this.blob = blob; - } - - public Blob getWrappedBlob() { - if ( blob == null ) { - throw new IllegalStateException( "Blobs may not be accessed after serialization" ); - } - else { - return blob; - } - } - - /** - * {@inheritDoc} - */ - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ( "getWrappedBlob".equals( method.getName() ) ) { - return getWrappedBlob(); - } - try { - return method.invoke( getWrappedBlob(), args ); - } - catch( AbstractMethodError e ) { - throw new HibernateException("The JDBC driver does not implement the method: " + method, e); - } - catch (InvocationTargetException e ) { - throw e.getTargetException(); - } - } - - /** - * Determines the appropriate class loader to which the generated proxy - * should be scoped. - * - * @return The class loader appropriate for proxy construction. - */ - public static ClassLoader getProxyClassLoader() { - ClassLoader cl = Thread.currentThread().getContextClassLoader(); - if ( cl == null ) { - cl = SerializableBlob.class.getClassLoader(); - } - return cl; - } -} Modified: core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClob.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClob.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClob.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -24,13 +24,76 @@ */ package org.hibernate.lob; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.Reader; import java.io.Serializable; +import java.io.Writer; import java.sql.Clob; +import java.sql.SQLException; /** * @author Gavin King */ -public interface SerializableClob extends Serializable, Clob { +public class SerializableClob implements Serializable, Clob { - public Clob getWrappedClob(); + private transient final Clob clob; + + public SerializableClob(Clob blob) { + this.clob = blob; + } + + public Clob getWrappedClob() { + if ( clob==null ) { + throw new IllegalStateException("Clobs may not be accessed after serialization"); + } + else { + return clob; + } + } + + public long length() throws SQLException { + return getWrappedClob().length(); + } + + public String getSubString(long pos, int length) throws SQLException { + return getWrappedClob().getSubString(pos, length); + } + + public Reader getCharacterStream() throws SQLException { + return getWrappedClob().getCharacterStream(); + } + + public InputStream getAsciiStream() throws SQLException { + return getWrappedClob().getAsciiStream(); + } + + public long position(String searchstr, long start) throws SQLException { + return getWrappedClob().position(searchstr, start); + } + + public long position(Clob searchstr, long start) throws SQLException { + return getWrappedClob().position(searchstr, start); + } + + public int setString(long pos, String str) throws SQLException { + return getWrappedClob().setString(pos, str); + } + + public int setString(long pos, String str, int offset, int len) throws SQLException { + return getWrappedClob().setString(pos, str, offset, len); + } + + public OutputStream setAsciiStream(long pos) throws SQLException { + return getWrappedClob().setAsciiStream(pos); + } + + public Writer setCharacterStream(long pos) throws SQLException { + return getWrappedClob().setCharacterStream(pos); + } + + public void truncate(long len) throws SQLException { + getWrappedClob().truncate(len); + } + } Deleted: core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClobProxy.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClobProxy.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/lob/SerializableClobProxy.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,105 +0,0 @@ -// $Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - */ -package org.hibernate.lob; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.sql.Clob; - -import org.hibernate.HibernateException; - -/** - * A proxy for SerializableClob objects which delegates all Clob methods to - * a wrapped Clob. - * - * @author Gail Badner - */ -public class SerializableClobProxy implements InvocationHandler { - - private static final Class[] PROXY_INTERFACES = new Class[] { SerializableClob.class }; - - private transient final Clob clob; - - /** - * Generates a SerializableClob proxy wrapping the provided Clob object. - * - * @param clob The Clob to wrap. - * @return The generated proxy. - */ - public static Clob generateProxy(Clob clob) { - return ( Clob ) Proxy.newProxyInstance( - getProxyClassLoader(), - PROXY_INTERFACES, - new SerializableClobProxy( clob ) - ); - } - - private SerializableClobProxy(Clob clob) { - this.clob = clob; - } - - public Clob getWrappedClob() { - if ( clob==null ) { - throw new IllegalStateException("Clobs may not be accessed after serialization"); - } - else { - return clob; - } - } - - /** - * {@inheritDoc} - */ - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ( "getWrappedClob".equals( method.getName() ) ) { - return getWrappedClob(); - } - try { - return method.invoke( getWrappedClob(), args ); - } - catch( AbstractMethodError e ) { - throw new HibernateException("The JDBC driver does not implement the method: " + method, e); - } - catch( InvocationTargetException e ) { - throw e.getTargetException(); - } - } - - /** - * Determines the appropriate class loader to which the generated proxy - * should be scoped. - * - * @return The class loader appropriate for proxy construction. - */ - public static ClassLoader getProxyClassLoader() { - ClassLoader cl = Thread.currentThread().getContextClassLoader(); - if ( cl == null ) { - cl = Clob.class.getClassLoader(); - } - return cl; - } -} Modified: core/branches/Branch_3_2/src/org/hibernate/type/BlobType.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/type/BlobType.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/type/BlobType.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -42,7 +42,6 @@ import org.hibernate.engine.SessionImplementor; import org.hibernate.lob.BlobImpl; import org.hibernate.lob.SerializableBlob; -import org.hibernate.lob.SerializableBlobProxy; import org.hibernate.util.ArrayHelper; /** @@ -80,7 +79,7 @@ public Object get(ResultSet rs, String name) throws HibernateException, SQLException { Blob value = rs.getBlob(name); - return rs.wasNull() ? null : SerializableBlobProxy.generateProxy(value); + return rs.wasNull() ? null : new SerializableBlob(value); } public Class getReturnedClass() { Modified: core/branches/Branch_3_2/src/org/hibernate/type/ClobType.java =================================================================== --- core/branches/Branch_3_2/src/org/hibernate/type/ClobType.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/src/org/hibernate/type/ClobType.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -43,7 +43,6 @@ import org.hibernate.engine.SessionImplementor; import org.hibernate.lob.ClobImpl; import org.hibernate.lob.SerializableClob; -import org.hibernate.lob.SerializableClobProxy; import org.hibernate.util.ArrayHelper; /** @@ -81,7 +80,7 @@ public Object get(ResultSet rs, String name) throws HibernateException, SQLException { Clob value = rs.getClob(name); - return rs.wasNull() ? null : SerializableClobProxy.generateProxy(value); + return rs.wasNull() ? null : new SerializableClob(value); } public Class getReturnedClass() { Modified: core/branches/Branch_3_2/test/org/hibernate/test/AllTests.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/AllTests.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/AllTests.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -148,17 +148,7 @@ import org.hibernate.test.legacy.SQLLoaderTest; import org.hibernate.test.legacy.StatisticsTest; import org.hibernate.test.lob.BlobTest; -import org.hibernate.test.lob.BlobFromLobCreatorDefaultTest; -import org.hibernate.test.lob.BlobFromLobCreatorJDBC3ConnRelOnCloseTest; -import org.hibernate.test.lob.BlobFromLobCreatorJDBC3Test; -import org.hibernate.test.lob.BlobFromLobCreatorJDBC4ConnRelOnCloseTest; -import org.hibernate.test.lob.BlobFromLobCreatorJDBC4Test; import org.hibernate.test.lob.ClobTest; -import org.hibernate.test.lob.ClobFromLobCreatorDefaultTest; -import org.hibernate.test.lob.ClobFromLobCreatorJDBC3ConnRelOnCloseTest; -import org.hibernate.test.lob.ClobFromLobCreatorJDBC3Test; -import org.hibernate.test.lob.ClobFromLobCreatorJDBC4ConnRelOnCloseTest; -import org.hibernate.test.lob.ClobFromLobCreatorJDBC4Test; import org.hibernate.test.lob.SerializableTypeTest; import org.hibernate.test.manytomany.ManyToManyTest; import org.hibernate.test.manytomanyassociationclass.compositeid.ManyToManyAssociationClassCompositeIdTest; @@ -483,17 +473,7 @@ suite.addTest( AnyTypeTest.suite() ); suite.addTest( SerializableTypeTest.suite() ); suite.addTest( BlobTest.suite() ); - suite.addTest( BlobFromLobCreatorDefaultTest.suite() ); - suite.addTest( BlobFromLobCreatorJDBC3ConnRelOnCloseTest.suite() ); - suite.addTest( BlobFromLobCreatorJDBC3Test.suite() ); - suite.addTest( BlobFromLobCreatorJDBC4ConnRelOnCloseTest.suite() ); - suite.addTest( BlobFromLobCreatorJDBC4Test.suite() ); suite.addTest( ClobTest.suite() ); - suite.addTest( ClobFromLobCreatorDefaultTest.suite() ); - suite.addTest( ClobFromLobCreatorJDBC3ConnRelOnCloseTest.suite() ); - suite.addTest( ClobFromLobCreatorJDBC3Test.suite() ); - suite.addTest( ClobFromLobCreatorJDBC4ConnRelOnCloseTest.suite() ); - suite.addTest( ClobFromLobCreatorJDBC4Test.suite() ); suite.addTest( IdentifierPropertyReferencesTest.suite() ); suite.addTest( DeleteTransientEntityTest.suite() ); suite.addTest( UserCollectionTypeTest.suite() ); @@ -653,4 +633,4 @@ } } } -} +} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobFromLobCreatorTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobFromLobCreatorTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobFromLobCreatorTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,161 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.Blob; -import java.sql.SQLException; -import java.sql.Connection; -import java.io.IOException; -import java.io.ByteArrayInputStream; - -import org.hibernate.Hibernate; -import org.hibernate.Session; -import org.hibernate.AssertionFailure; -import org.hibernate.HibernateException; -import org.hibernate.SessionException; -import org.hibernate.lob.LobCreator; -import org.hibernate.engine.SessionFactoryImplementor; -import org.hibernate.cfg.Environment; -import org.hibernate.cfg.Configuration; -import org.hibernate.dialect.Dialect; - -/** - * This class extends AbstractBlobTest to provide additional tests when - * using a LobCreator to create LOB locators. - * - * @author Gail Badner - */ -public abstract class AbstractBlobFromLobCreatorTest extends AbstractBlobTest { - - public AbstractBlobFromLobCreatorTest(String name) { - super( name ); - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - if ( getUseConnectionForLobCreationPropertyValue() == null ) { - cfg.setProperty( Environment.USE_CONNECTION_FOR_LOB_CREATION, "" ); - } - else { - cfg.setProperty( - Environment.USE_CONNECTION_FOR_LOB_CREATION, - String.valueOf( getUseConnectionForLobCreationPropertyValue().booleanValue() ) - ); - } - } - - public boolean appliesTo(Dialect dialect) { - if ( ! dialect.supportsExpectedLobUsagePattern() ) { - reportSkip( "database/driver does not support expected LOB usage pattern", "LOB support" ); - return false; - } - return true; - } - - protected abstract Boolean getUseConnectionForLobCreationPropertyValue(); - - protected Blob createBlobLocator(Session s, byte[] bytes) { - return Hibernate.getLobCreator( s ).createBlob( bytes ); - } - - protected Blob createBlobLocatorFromStream(Session s, byte[] bytes) throws IOException { - return Hibernate.getLobCreator( s ).createBlob( new ByteArrayInputStream( bytes ) ); - } - - protected Blob createBlobLocatorFromStreamUsingLength(Session s, byte[] bytes) throws IOException { - return Hibernate.getLobCreator( s ).createBlob( new ByteArrayInputStream( bytes ), bytes.length ); - } - - protected abstract Class getExpectedLobCreatorClass() throws SQLException ; - - public void testUseConnectionForLobCreationEnabledSetting() throws SQLException { - Boolean propVal = getUseConnectionForLobCreationPropertyValue(); - if ( propVal == null ) { - if ( jvmAndDriverSupportUseConnectionForLobCreation() != isUseConnectionForLobCreationEnabled() ) { - throw new AssertionFailure( "JVM and JDBC driver support is inconsistent with setting for using Connection to create LOBs." ); - - } - } - else { - if ( propVal.booleanValue() != isUseConnectionForLobCreationEnabled() ) { - throw new AssertionFailure( "Non-null Environment.USE_CONNECTION_FOR_LOB_CREATION value is inconstent with setting." ); - } - } - } - - public void testCorrectLobCreator() throws Exception { - Session s = openSession(); - LobCreator lobCreator = Hibernate.getLobCreator( s ); - assertEquals( getExpectedLobCreatorClass(), lobCreator.getClass() ); - s.close(); - } - - public void testGetLobCreatorWithNullSession() { - try { - Hibernate.getLobCreator( null ); - fail( "should have failed with null session" ); - } - catch ( AssertionFailure ex ) { - // expected - } - } - - public void testCreateBlobLocatorAfterSessionClose() throws Throwable { - Session s = openSession(); - s.close(); - byte[] bytes = buildRecursively( BLOB_SIZE, true ); - try { - createBlobLocator( s, bytes ); - if ( isUseConnectionForLobCreationEnabled() ) { - fail( "should have failed w/ SessionException" ); - } - } - catch ( SessionException e ) { - if ( ! isUseConnectionForLobCreationEnabled() ) { - fail( "should not have failed w/ SessionException" ); - } - } - } - - protected boolean isUseConnectionForLobCreationEnabled() { - return ( ( SessionFactoryImplementor ) getSessions() ).getSettings().isUseConnectionForLobCreationEnabled(); - } - - protected boolean jvmAndDriverSupportUseConnectionForLobCreation() throws SQLException { - if ( ! Environment.jvmSupportsJDBC4() ) { - return false; - } - Class c = ( ( SessionFactoryImplementor ) getSessions() ).getConnectionProvider().getConnection().getClass(); - try { - return !( Connection.class.equals( c.getMethod( "createBlob", new Class[0] ).getDeclaringClass() ) || - Connection.class.equals( c.getMethod( "createClob", new Class[0] ).getDeclaringClass() ) ); - } - catch ( NoSuchMethodException e ) { - return false; - } - } - -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractBlobTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,490 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.Blob; -import java.sql.SQLException; -import java.io.IOException; - -import junit.framework.AssertionFailedError; - -import org.hibernate.LockMode; -import org.hibernate.Session; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.Environment; -import org.hibernate.dialect.Dialect; -import org.hibernate.junit.functional.DatabaseSpecificFunctionalTestCase; -import org.hibernate.util.ArrayHelper; - -/** - * Test various access scenarios for eager and lazy materialization - * of BLOB data, as well as bounded and unbounded materialization - * and mutation. - * - * @author Steve Ebersole - */ -public abstract class AbstractBlobTest extends DatabaseSpecificFunctionalTestCase { - public static final int BLOB_SIZE = 10000; - - public AbstractBlobTest(String name) { - super( name ); - } - - public String[] getMappings() { - return new String[] { "lob/LobMappings.hbm.xml" }; - } - - public boolean appliesTo(Dialect dialect) { - if ( ! dialect.supportsExpectedLobUsagePattern() ) { - reportSkip( "database/driver does not support expected LOB usage pattern", "LOB support" ); - return false; - } - return true; - } - - protected abstract Blob createBlobLocator(Session s, byte[] bytes); - - protected abstract Blob createBlobLocatorFromStream(Session s, byte[] bytes) throws IOException; - - protected abstract Blob createBlobLocatorFromStreamUsingLength(Session s, byte[] bytes) throws IOException ; - - protected boolean skipLobLocatorTests() throws SQLException { - return false; - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - // set connection pool size to 0 so that tests will always use a clean connection; - // this ensures that the test does not use LOB data left on the connection from - // prior to being returned to the connection pool. - cfg.setProperty( Environment.POOL_SIZE, "0" ); - // ConnectionReleaseMode.AFTER_TRANSACTION is the default for non-JTA connection. - // The Connection used for the unit tests is non-JTA. This setting for - // Environment.RELEASE_CONNECTIONS is just to make it explicit for these tests. - cfg.setProperty( Environment.RELEASE_CONNECTIONS, "after_transaction" ); - } - - public void testBoundedMaterializedBlobAccess() { - byte[] original = buildRecursively( BLOB_SIZE, true ); - byte[] changed = buildRecursively( BLOB_SIZE, false ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setMaterializedBlob( original ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getMaterializedBlob().length ); - assertEquals( original, entity.getMaterializedBlob() ); - entity.setMaterializedBlob( changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getMaterializedBlob().length ); - assertEquals( changed, entity.getMaterializedBlob() ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testBoundedBlobLocatorAccess() throws Throwable { - if ( skipLobLocatorTests() ) { - return; - } - - byte[] original = buildRecursively( BLOB_SIZE, true ); - byte[] changed = buildRecursively( BLOB_SIZE, false ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setBlobLocator( createBlobLocator( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - s.getTransaction().commit(); - s.close(); - - // test mutation via setting the new blob data... - if ( supportsLobValueChangePropogation() ) { - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - entity.getBlobLocator().truncate( 1 ); - entity.getBlobLocator().setBytes( 1, changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getBlobLocator() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( changed, extractData( entity.getBlobLocator() ) ); - entity.getBlobLocator().truncate( 1 ); - entity.getBlobLocator().setBytes( 1, original ); - s.getTransaction().commit(); - s.close(); - } - - // test mutation via supplying a new blob locator instance... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getBlobLocator() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - entity.setBlobLocator( createBlobLocator( s, changed ) ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( changed, extractData( entity.getBlobLocator() ) ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testBoundedBlobLocatorAccessFromStream() throws Throwable { - if ( skipLobLocatorTests() ) { - return; - } - - byte[] original = buildRecursively( BLOB_SIZE, true ); - byte[] changed = buildRecursively( BLOB_SIZE, false ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setBlobLocator( createBlobLocatorFromStream( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - s.getTransaction().commit(); - s.close(); - - // test mutation via setting the new blob data... - if ( supportsLobValueChangePropogation() ) { - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - entity.getBlobLocator().truncate( 1 ); - entity.getBlobLocator().setBytes( 1, changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getBlobLocator() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( changed, extractData( entity.getBlobLocator() ) ); - entity.getBlobLocator().truncate( 1 ); - entity.getBlobLocator().setBytes( 1, original ); - s.getTransaction().commit(); - s.close(); - } - - // test mutation via supplying a new blob locator instance... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getBlobLocator() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - entity.setBlobLocator( createBlobLocatorFromStream( s, changed ) ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( changed, extractData( entity.getBlobLocator() ) ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - - } - - public void testBoundedBlobLocatorAccessFromStreamUsingLength() throws Throwable { - if ( skipLobLocatorTests() ) { - return; - } - - byte[] original = buildRecursively( BLOB_SIZE, true ); - byte[] changed = buildRecursively( BLOB_SIZE, false ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setBlobLocator( createBlobLocatorFromStreamUsingLength( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - s.getTransaction().commit(); - s.close(); - - // test mutation via setting the new blob data... - if ( supportsLobValueChangePropogation() ) { - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - entity.getBlobLocator().truncate( 1 ); - entity.getBlobLocator().setBytes( 1, changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getBlobLocator() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( changed, extractData( entity.getBlobLocator() ) ); - entity.getBlobLocator().truncate( 1 ); - entity.getBlobLocator().setBytes( 1, original ); - s.getTransaction().commit(); - s.close(); - } - - // test mutation via supplying a new blob locator instance... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getBlobLocator() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - entity.setBlobLocator( createBlobLocatorFromStreamUsingLength( s, changed ) ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( changed, extractData( entity.getBlobLocator() ) ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - - } - - public void testUnboundedBlobLocatorAccess() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - - // Note: unbounded mutation of the underlying lob data is completely - // unsupported; most databases would not allow such a construct anyway. - // Thus here we are only testing materialization... - - byte[] original = buildRecursively( BLOB_SIZE, true ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setBlobLocator( createBlobLocator( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - // load the entity with the blob locator, and close the session/transaction; - // at that point it is unbounded... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - s.getTransaction().commit(); - s.close(); - - assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); - assertEquals( original, extractData( entity.getBlobLocator() ) ); - - s = openSession(); - s.beginTransaction(); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testCreateAndAccessLobLocatorInSessionNoTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - byte[] bytes = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - s.close(); - } - - public void testCreateAndAccessLobLocatorInTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - byte bytes[] = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - s.getTransaction().commit(); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessOutOfTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - byte bytes[] = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - s.getTransaction().commit(); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessInNextTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - byte bytes[] = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - s.getTransaction().commit(); - s.getTransaction().begin(); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - s.getTransaction().commit(); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessAfterSessionClose() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - byte bytes[] = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - s.getTransaction().commit(); - s.close(); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - } - - public void testCreateLobLocatorInTransactionAccessInNextSession() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - byte bytes[] = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - s.getTransaction().commit(); - s.close(); - s = openSession(); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessInNextSessionTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - byte bytes[] = buildRecursively( BLOB_SIZE, true ); - Blob blob = createBlobLocator( s, bytes ); - s.getTransaction().commit(); - s.close(); - s = openSession(); - s.getTransaction().begin(); - assertEquals( BLOB_SIZE, blob.length() ); - assertEquals( bytes, extractData( blob ) ); - s.getTransaction().commit(); - s.close(); - } - - protected byte[] extractData(Blob blob) throws Throwable { - byte bytesRead[] = new byte[ ( int ) blob.length() ]; - blob.getBinaryStream().read( bytesRead ); - return bytesRead; - } - - protected byte[] buildRecursively(int size, boolean on) { - byte[] data = new byte[size]; - data[0] = mask( on ); - for ( int i = 0; i < size; i++ ) { - data[i] = mask( on ); - on = !on; - } - return data; - } - - private byte mask(boolean on) { - return on ? ( byte ) 1 : ( byte ) 0; - } - - public static void assertEquals(byte[] val1, byte[] val2) { - if ( !ArrayHelper.isEquals( val1, val2 ) ) { - throw new AssertionFailedError( "byte arrays did not match" ); - } - } -} Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobFromLobCreatorTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobFromLobCreatorTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobFromLobCreatorTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,156 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.SQLException; -import java.sql.Connection; -import java.sql.Clob; -import java.io.IOException; -import java.io.StringReader; - -import org.hibernate.Hibernate; -import org.hibernate.Session; -import org.hibernate.AssertionFailure; -import org.hibernate.SessionException; -import org.hibernate.lob.LobCreator; -import org.hibernate.engine.SessionFactoryImplementor; -import org.hibernate.cfg.Environment; -import org.hibernate.cfg.Configuration; -import org.hibernate.dialect.Dialect; - -/** - * This class extends AbstractClobTest to provide additional tests when - * using a LobCreator to create LOB locators. - * - * @author Gail Badner - */ -public abstract class AbstractClobFromLobCreatorTest extends AbstractClobTest { - - public AbstractClobFromLobCreatorTest(String name) { - super( name ); - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - if ( getUseConnectionForLobCreationPropertyValue() == null ) { - cfg.setProperty( Environment.USE_CONNECTION_FOR_LOB_CREATION, "" ); - } - else { - cfg.setProperty( - Environment.USE_CONNECTION_FOR_LOB_CREATION, - String.valueOf( getUseConnectionForLobCreationPropertyValue().booleanValue() ) - ); - } - } - - public boolean appliesTo(Dialect dialect) { - if ( ! dialect.supportsExpectedLobUsagePattern() ) { - reportSkip( "database/driver does not support expected LOB usage pattern", "LOB support" ); - return false; - } - return true; - } - - protected abstract Boolean getUseConnectionForLobCreationPropertyValue(); - - protected Clob createClobLocator(Session s, String str) { - return Hibernate.getLobCreator( s ).createClob( str ); - } - - protected Clob createClobLocatorFromStreamUsingLength(Session s, String str) throws IOException { - return Hibernate.getLobCreator( s ).createClob( new StringReader( str ), str.length() ); - } - - protected abstract Class getExpectedLobCreatorClass() throws SQLException ; - - public void testUseConnectionForLobCreationEnabledSetting() throws SQLException { - Boolean propVal = getUseConnectionForLobCreationPropertyValue(); - if ( propVal == null ) { - if ( jvmAndDriverSupportUseConnectionForLobCreation() != isUseConnectionForLobCreationEnabled() ) { - throw new AssertionFailure( "JVM and JDBC driver support is inconsistent with setting for using Connection to create LOBs." ); - - } - } - else { - if ( propVal.booleanValue() != isUseConnectionForLobCreationEnabled() ) { - throw new AssertionFailure( "Non-null Environment.USE_CONNECTION_FOR_LOB_CREATION value is inconstent with setting." ); - } - } - } - - public void testCorrectLobCreator() throws Exception { - Session s = openSession(); - LobCreator lobCreator = Hibernate.getLobCreator( s ); - assertEquals( getExpectedLobCreatorClass(), lobCreator.getClass() ); - s.close(); - } - - public void testGetLobCreatorWithNullSession() { - try { - Hibernate.getLobCreator( null ); - fail( "should have failed with null session" ); - } - catch ( AssertionFailure ex ) { - // expected - } - } - - public void testCreateClobLocatorAfterSessionClose() throws Throwable { - Session s = openSession(); - s.close(); - String str = buildRecursively( CLOB_SIZE, 'x'); - try { - createClobLocator( s, str ); - if ( isUseConnectionForLobCreationEnabled() ) { - fail( "should have failed w/ SessionException" ); - } - } - catch ( SessionException e ) { - if ( ! isUseConnectionForLobCreationEnabled() ) { - fail( "should not have failed w/ SessionException" ); - } - } - } - - protected boolean isUseConnectionForLobCreationEnabled() { - return ( ( SessionFactoryImplementor ) getSessions() ).getSettings().isUseConnectionForLobCreationEnabled(); - } - - protected boolean jvmAndDriverSupportUseConnectionForLobCreation() throws SQLException { - if ( ! Environment.jvmSupportsJDBC4() ) { - return false; - } - Class c = ( ( SessionFactoryImplementor ) getSessions() ).getConnectionProvider().getConnection().getClass(); - try { - return !( Connection.class.equals( c.getMethod( "createBlob", new Class[0] ).getDeclaringClass() ) || - Connection.class.equals( c.getMethod( "createClob", new Class[0] ).getDeclaringClass() ) ); - } - catch ( NoSuchMethodException e ) { - return false; - } - } - -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/AbstractClobTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,410 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.SQLException; -import java.sql.Clob; -import java.io.IOException; - -import org.hibernate.LockMode; -import org.hibernate.Session; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.Environment; -import org.hibernate.dialect.Dialect; -import org.hibernate.dialect.H2Dialect; -import org.hibernate.junit.functional.DatabaseSpecificFunctionalTestCase; - -/** - * Test various access scenarios for eager and lazy materialization - * of CLOB data, as well as bounded and unbounded materialization - * and mutation. - * - * @author Steve Ebersole - */ -public abstract class AbstractClobTest extends DatabaseSpecificFunctionalTestCase { - public static final int CLOB_SIZE = 10000; - - public AbstractClobTest(String name) { - super( name ); - } - - public String[] getMappings() { - return new String[] { "lob/LobMappings.hbm.xml" }; - } - - public boolean appliesTo(Dialect dialect) { - if ( ! dialect.supportsExpectedLobUsagePattern() ) { - reportSkip( "database/driver does not support expected LOB usage pattern", "LOB support" ); - return false; - } - return true; - } - - protected abstract Clob createClobLocator(Session s, String str); - - protected abstract Clob createClobLocatorFromStreamUsingLength(Session s, String str ) throws IOException ; - - protected boolean skipLobLocatorTests() throws SQLException { - return false; - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - // set connection pool size to 0 so that tests will always use a clean connection; - // this ensures that the test does not use LOB data left on the connection from - // prior to being returned to the connection pool. - cfg.setProperty( Environment.POOL_SIZE, "0" ); - // ConnectionReleaseMode.AFTER_TRANSACTION is the default for non-JTA connection. - // The Connection used for the unit tests is non-JTA. This setting for - // Environment.RELEASE_CONNECTIONS is just to make it explicit for these tests. - cfg.setProperty( Environment.RELEASE_CONNECTIONS, "after_transaction" ); - } - - public void testBoundedMaterializedClobAccess() { - String original = buildRecursively( CLOB_SIZE, 'x' ); - String changed = buildRecursively( CLOB_SIZE, 'y' ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setMaterializedClob( original ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( CLOB_SIZE, entity.getMaterializedClob().length() ); - assertEquals( original, entity.getMaterializedClob() ); - entity.setMaterializedClob( changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( CLOB_SIZE, entity.getMaterializedClob().length() ); - assertEquals( changed, entity.getMaterializedClob() ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testBoundedClobLocatorAccess() throws Throwable { - if ( skipLobLocatorTests() ) { - return; - } - - String original = buildRecursively( CLOB_SIZE, 'x'); - String changed = buildRecursively( CLOB_SIZE, 'y' ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setClobLocator( createClobLocator( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( original, extractData( entity.getClobLocator() ) ); - s.getTransaction().commit(); - s.close(); - - // test mutation via setting the new clob data... - if ( supportsLobValueChangePropogation() ) { - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - entity.getClobLocator().truncate( 1 ); - entity.getClobLocator().setString( 1, changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getClobLocator() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( changed, extractData( entity.getClobLocator() ) ); - entity.getClobLocator().truncate( 1 ); - entity.getClobLocator().setString( 1, original ); - s.getTransaction().commit(); - s.close(); - } - - // test mutation via supplying a new clob locator instance... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getClobLocator() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( original, extractData( entity.getClobLocator() ) ); - entity.setClobLocator( createClobLocator( s, changed ) ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( changed, extractData( entity.getClobLocator() ) ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testBoundedClobLocatorAccessFromStreamUsingLength() throws Throwable { - if ( skipLobLocatorTests() ) { - return; - } - - String original = buildRecursively( CLOB_SIZE, 'x'); - String changed = buildRecursively( CLOB_SIZE, 'y' ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setClobLocator( createClobLocatorFromStreamUsingLength( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( original, extractData( entity.getClobLocator() ) ); - s.getTransaction().commit(); - s.close(); - - // test mutation via setting the new clob data... - if ( supportsLobValueChangePropogation() ) { - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - entity.getClobLocator().truncate( 1 ); - entity.getClobLocator().setString( 1, changed ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getClobLocator() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( changed, extractData( entity.getClobLocator() ) ); - entity.getClobLocator().truncate( 1 ); - entity.getClobLocator().setString( 1, original ); - s.getTransaction().commit(); - s.close(); - } - - // test mutation via supplying a new clob locator instance... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); - assertNotNull( entity.getClobLocator() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( original, extractData( entity.getClobLocator() ) ); - entity.setClobLocator( createClobLocatorFromStreamUsingLength( s, changed ) ); - s.getTransaction().commit(); - s.close(); - - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( changed, extractData( entity.getClobLocator() ) ); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testUnboundedClobLocatorAccess() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - - // Note: unbounded mutation of the underlying lob data is completely - // unsupported; most databases would not allow such a construct anyway. - // Thus here we are only testing materialization... - - String original = buildRecursively( CLOB_SIZE, 'x' ); - - Session s = openSession(); - s.beginTransaction(); - LobHolder entity = new LobHolder(); - entity.setClobLocator( createClobLocator( s, original ) ); - s.save( entity ); - s.getTransaction().commit(); - s.close(); - - // load the entity with the clob locator, and close the session/transaction; - // at that point it is unbounded... - s = openSession(); - s.beginTransaction(); - entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); - s.getTransaction().commit(); - s.close(); - - assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); - assertEquals( original, extractData( entity.getClobLocator() ) ); - - s = openSession(); - s.beginTransaction(); - s.delete( entity ); - s.getTransaction().commit(); - s.close(); - } - - public void testCreateAndAccessLobLocatorInSessionNoTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - s.close(); - } - - public void testCreateAndAccessLobLocatorInTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - s.getTransaction().commit(); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessOutOfTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - s.getTransaction().commit(); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessInNextTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - s.getTransaction().commit(); - s.getTransaction().begin(); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - s.getTransaction().commit(); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessAfterSessionClose() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - s.getTransaction().commit(); - s.close(); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - } - - public void testCreateLobLocatorInTransactionAccessInNextSession() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - s.getTransaction().commit(); - s.close(); - s = openSession(); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - s.close(); - } - - public void testCreateLobLocatorInTransactionAccessInNextSessionTransaction() throws Throwable { - if ( skipLobLocatorTests() || ! supportsUnboundedLobLocatorMaterialization() ) { - return; - } - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - Clob clob = createClobLocator( s, str ); - s.getTransaction().commit(); - s.close(); - s = openSession(); - s.getTransaction().begin(); - assertEquals( CLOB_SIZE, clob.length() ); - assertEquals( str, extractData( clob ) ); - s.getTransaction().commit(); - s.close(); - } - - protected String extractData(Clob clob) throws Throwable { - if ( getDialect() instanceof H2Dialect ) { - return clob.getSubString( 1, ( int ) clob.length() ); - } - else { - char[] data = new char[ (int) clob.length() ]; - clob.getCharacterStream().read( data ); - return new String( data ); - } - } - - protected String buildRecursively(int size, char baseChar) { - StringBuffer buff = new StringBuffer(); - for( int i = 0; i < size; i++ ) { - buff.append( baseChar ); - } - return buff.toString(); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorDefaultTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorDefaultTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorDefaultTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,65 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.SQLException; - -import junit.framework.Test; - -import org.hibernate.lob.LobCreatorImplJDBC4; -import org.hibernate.lob.LobCreatorImplJDBC3; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; - -/** - * This class extends AbstractBlobFromLobCreatorTest to provide logic to - * determine if the correct LobCreator impl is used when - * Environment.USE_CONNECTION_FOR_LOB_CREATION is not set. The actual impl - * will depend on whether the JVM and driver support creating LOBs using - * the connection. - * - * @author Gail Badner - */ -public class BlobFromLobCreatorDefaultTest extends AbstractBlobFromLobCreatorTest { - - public BlobFromLobCreatorDefaultTest(String name) { - super( name ); - } - - protected Boolean getUseConnectionForLobCreationPropertyValue() { - return null; - } - - protected Class getExpectedLobCreatorClass() throws SQLException { - return ( jvmAndDriverSupportUseConnectionForLobCreation() ? - LobCreatorImplJDBC4.class : - LobCreatorImplJDBC3.class - ); - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( BlobFromLobCreatorDefaultTest.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3ConnRelOnCloseTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3ConnRelOnCloseTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3ConnRelOnCloseTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,54 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import junit.framework.Test; - -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.Environment; - -/** - * This class extends BlobFromLobCreatorJDBC3Test to run tests - * using connection release mode "on_close". - * - * @author Gail Badner - */ -public class BlobFromLobCreatorJDBC3ConnRelOnCloseTest extends BlobFromLobCreatorJDBC3Test { - - public BlobFromLobCreatorJDBC3ConnRelOnCloseTest(String name) { - super( name ); - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - cfg.setProperty( Environment.RELEASE_CONNECTIONS, "on_close" ); - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( BlobFromLobCreatorJDBC3ConnRelOnCloseTest.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3Test.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3Test.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC3Test.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,59 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import junit.framework.Test; - -import org.hibernate.lob.LobCreatorImplJDBC3; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; - -/** - * This class extends AbstractBlobFromLobCreatorTest to determine if the - * correct LobCreator impl is used when Environment.USE_CONNECTION_FOR_LOB_CREATION - * is set to false. The actual impl should be the JDBC3 LobCreator, even when - * the JVM and JDBC driver support JDBC4. The JDBC3 LobCreator does not use the - * Connection to create LOBs. - * - * @author Gail Badner - */ -public class BlobFromLobCreatorJDBC3Test extends AbstractBlobFromLobCreatorTest { - - public BlobFromLobCreatorJDBC3Test(String name) { - super( name ); - } - - protected Boolean getUseConnectionForLobCreationPropertyValue() { - return Boolean.FALSE; - } - - protected Class getExpectedLobCreatorClass() { - return LobCreatorImplJDBC3.class; - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( BlobFromLobCreatorJDBC3Test.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4ConnRelOnCloseTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4ConnRelOnCloseTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4ConnRelOnCloseTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,54 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import junit.framework.Test; - -import org.hibernate.cfg.Environment; -import org.hibernate.cfg.Configuration; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; - -/** - * This class extends BlobFromLobCreatorJDBC4Test to run tests - * using connection release mode "on_close". - * - * @author Gail Badner - */ -public class BlobFromLobCreatorJDBC4ConnRelOnCloseTest extends BlobFromLobCreatorJDBC4Test { - - public BlobFromLobCreatorJDBC4ConnRelOnCloseTest(String name) { - super( name ); - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - cfg.setProperty( Environment.RELEASE_CONNECTIONS, "on_close" ); - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( BlobFromLobCreatorJDBC4ConnRelOnCloseTest.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4Test.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4Test.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobFromLobCreatorJDBC4Test.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,112 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.SQLException; -import java.sql.Blob; - -import junit.framework.Test; - -import org.hibernate.lob.LobCreatorImplJDBC4; -import org.hibernate.cfg.Environment; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; -import org.hibernate.Session; -import org.hibernate.HibernateException; - -/** - * This class extends AbstractBlobFromLobCreatorTest to determine if the - * correct LobCreator impl is used when Environment.USE_CONNECTION_FOR_LOB_CREATION - * is set to true. The actual impl should be the JDBC4 LobCreator, even when - * the JVM and/or JDBC driver do not support JDBC4. The JDBC4 LobCreator uses the - * Connection to create LOBs. - * - * @author Gail Badner - */ -public class BlobFromLobCreatorJDBC4Test extends AbstractBlobFromLobCreatorTest { - - public BlobFromLobCreatorJDBC4Test(String name) { - super( name ); - } - - protected Boolean getUseConnectionForLobCreationPropertyValue() { - return Boolean.TRUE; - } - - protected Class getExpectedLobCreatorClass() { - return LobCreatorImplJDBC4.class; - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( BlobFromLobCreatorJDBC4Test.class ); - } - - protected boolean skipLobLocatorTests() throws SQLException { - if ( ! Environment.jvmSupportsJDBC4() ) { - reportSkip( "JVM does not support creating LOBs using the connection", "LOB support" ); - return true; - } - if ( ! jvmAndDriverSupportUseConnectionForLobCreation() ) { - reportSkip( "Driver does not support creating LOBs using the connection", "LOB support" ); - return true; - } - return false; - } - - public void testCreateBlobLocatorSupport() throws Throwable { - Session s = openSession(); - s.getTransaction().begin(); - byte[] bytes = buildRecursively( BLOB_SIZE, true ); - try { - Blob blob = createBlobLocator( s, bytes ); - if ( ! Environment.jvmSupportsJDBC4() ) { - fail( "should have thrown NoSuchMethodException" ); - } - else if ( ! jvmAndDriverSupportUseConnectionForLobCreation() ) { - fail( "should have thrown AbstractMethodException" ); - } - assertEquals( bytes, extractData( blob ) ); - s.getTransaction().commit(); - } - catch( HibernateException e ) { - s.getTransaction().rollback(); - if ( e.getCause() instanceof NoSuchMethodException ) { - assertTrue( ! Environment.jvmSupportsJDBC4() && - isUseConnectionForLobCreationEnabled() ); - } - else if ( e.getCause() instanceof AbstractMethodError ) { - assertTrue( Environment.jvmSupportsJDBC4() && - ! jvmAndDriverSupportUseConnectionForLobCreation() && - isUseConnectionForLobCreationEnabled() ); - } - else { - throw e; - } - } - finally { - s.close(); - } - } -} \ No newline at end of file Modified: core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/BlobTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -26,42 +26,200 @@ package org.hibernate.test.lob; import java.sql.Blob; -import java.io.ByteArrayInputStream; -import java.io.IOException; +import junit.framework.AssertionFailedError; import junit.framework.Test; import org.hibernate.Hibernate; +import org.hibernate.LockMode; import org.hibernate.Session; +import org.hibernate.dialect.Dialect; +import org.hibernate.junit.functional.DatabaseSpecificFunctionalTestCase; import org.hibernate.junit.functional.FunctionalTestClassTestSuite; +import org.hibernate.util.ArrayHelper; /** - * This class extends AbstractBlobTest so that LOBs are created using the - * Hibernate.createBlob() APIs. These APIs do not use the connection to - * create LOBs. + * {@inheritDoc} * * @author Steve Ebersole */ -public class BlobTest extends AbstractBlobTest { +public class BlobTest extends DatabaseSpecificFunctionalTestCase { + private static final int BLOB_SIZE = 10000; public BlobTest(String name) { super( name ); } + public String[] getMappings() { + return new String[] { "lob/LobMappings.hbm.xml" }; + } + public static Test suite() { return new FunctionalTestClassTestSuite( BlobTest.class ); } - protected Blob createBlobLocator(Session s, byte[] bytes) { - return Hibernate.createBlob( bytes ); + public boolean appliesTo(Dialect dialect) { + if ( ! dialect.supportsExpectedLobUsagePattern() ) { + reportSkip( "database/driver does not support expected LOB usage pattern", "LOB support" ); + return false; + } + return true; } - protected Blob createBlobLocatorFromStream(Session s, byte[] bytes) throws IOException { - return Hibernate.createBlob( new ByteArrayInputStream( bytes ) ); + public void testBoundedMaterializedBlobAccess() { + byte[] original = buildRecursively( BLOB_SIZE, true ); + byte[] changed = buildRecursively( BLOB_SIZE, false ); + + Session s = openSession(); + s.beginTransaction(); + LobHolder entity = new LobHolder(); + entity.setMaterializedBlob( original ); + s.save( entity ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( BLOB_SIZE, entity.getMaterializedBlob().length ); + assertEquals( original, entity.getMaterializedBlob() ); + entity.setMaterializedBlob( changed ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( BLOB_SIZE, entity.getMaterializedBlob().length ); + assertEquals( changed, entity.getMaterializedBlob() ); + s.delete( entity ); + s.getTransaction().commit(); + s.close(); } - protected Blob createBlobLocatorFromStreamUsingLength(Session s, byte[] bytes) throws IOException { - return Hibernate.createBlob( new ByteArrayInputStream( bytes ), bytes.length ); + public void testBoundedBlobLocatorAccess() throws Throwable { + byte[] original = buildRecursively( BLOB_SIZE, true ); + byte[] changed = buildRecursively( BLOB_SIZE, false ); + + Session s = openSession(); + s.beginTransaction(); + LobHolder entity = new LobHolder(); + entity.setBlobLocator( Hibernate.createBlob( original ) ); + s.save( entity ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); + assertEquals( original, extractData( entity.getBlobLocator() ) ); + s.getTransaction().commit(); + s.close(); + + // test mutation via setting the new clob data... + if ( supportsLobValueChangePropogation() ) { + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); + entity.getBlobLocator().truncate( 1 ); + entity.getBlobLocator().setBytes( 1, changed ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); + assertNotNull( entity.getBlobLocator() ); + assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); + assertEquals( changed, extractData( entity.getBlobLocator() ) ); + entity.getBlobLocator().truncate( 1 ); + entity.getBlobLocator().setBytes( 1, original ); + s.getTransaction().commit(); + s.close(); + } + + // test mutation via supplying a new clob locator instance... + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); + assertNotNull( entity.getBlobLocator() ); + assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); + assertEquals( original, extractData( entity.getBlobLocator() ) ); + entity.setBlobLocator( Hibernate.createBlob( changed ) ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); + assertEquals( changed, extractData( entity.getBlobLocator() ) ); + s.delete( entity ); + s.getTransaction().commit(); + s.close(); + } + + public void testUnboundedBlobLocatorAccess() throws Throwable { + if ( ! supportsUnboundedLobLocatorMaterialization() ) { + return; + } + + // Note: unbounded mutation of the underlying lob data is completely + // unsupported; most databases would not allow such a construct anyway. + // Thus here we are only testing materialization... + + byte[] original = buildRecursively( BLOB_SIZE, true ); + + Session s = openSession(); + s.beginTransaction(); + LobHolder entity = new LobHolder(); + entity.setBlobLocator( Hibernate.createBlob( original ) ); + s.save( entity ); + s.getTransaction().commit(); + s.close(); + + // load the entity with the clob locator, and close the session/transaction; + // at that point it is unbounded... + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + s.getTransaction().commit(); + s.close(); + + assertEquals( BLOB_SIZE, entity.getBlobLocator().length() ); + assertEquals( original, extractData( entity.getBlobLocator() ) ); + + s = openSession(); + s.beginTransaction(); + s.delete( entity ); + s.getTransaction().commit(); + s.close(); + } + + private byte[] extractData(Blob blob) throws Throwable { + return blob.getBytes( 1, ( int ) blob.length() ); + } + + + private byte[] buildRecursively(int size, boolean on) { + byte[] data = new byte[size]; + data[0] = mask( on ); + for ( int i = 0; i < size; i++ ) { + data[i] = mask( on ); + on = !on; + } + return data; + } + + private byte mask(boolean on) { + return on ? ( byte ) 1 : ( byte ) 0; + } + + public static void assertEquals(byte[] val1, byte[] val2) { + if ( !ArrayHelper.isEquals( val1, val2 ) ) { + throw new AssertionFailedError( "byte arrays did not match" ); + } + } } - Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorDefaultTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorDefaultTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorDefaultTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,65 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.SQLException; - -import junit.framework.Test; - -import org.hibernate.lob.LobCreatorImplJDBC4; -import org.hibernate.lob.LobCreatorImplJDBC3; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; - -/** - * This class extends AbstractClobFromLobCreatorTest to provide logic to - * determine if the correct LobCreator impl is used when - * Environment.USE_CONNECTION_FOR_LOB_CREATION is not set. The actual impl - * will depend on whether the JVM and driver support creating LOBs using - * the connection. - * - * @author Gail Badner - */ -public class ClobFromLobCreatorDefaultTest extends AbstractClobFromLobCreatorTest { - - public ClobFromLobCreatorDefaultTest(String name) { - super( name ); - } - - protected Boolean getUseConnectionForLobCreationPropertyValue() { - return null; - } - - protected Class getExpectedLobCreatorClass() throws SQLException { - return ( jvmAndDriverSupportUseConnectionForLobCreation() ? - LobCreatorImplJDBC4.class : - LobCreatorImplJDBC3.class - ); - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( ClobFromLobCreatorDefaultTest.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3ConnRelOnCloseTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3ConnRelOnCloseTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3ConnRelOnCloseTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,54 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import junit.framework.Test; - -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.Environment; - -/** - * This class extends ClobFromLobCreatorJDBC3Test to run tests - * using connection release mode "on_close". - * - * @author Gail Badner - */ -public class ClobFromLobCreatorJDBC3ConnRelOnCloseTest extends ClobFromLobCreatorJDBC3Test { - - public ClobFromLobCreatorJDBC3ConnRelOnCloseTest(String name) { - super( name ); - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - cfg.setProperty( Environment.RELEASE_CONNECTIONS, "on_close" ); - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( ClobFromLobCreatorJDBC3ConnRelOnCloseTest.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3Test.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3Test.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC3Test.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,59 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import junit.framework.Test; - -import org.hibernate.lob.LobCreatorImplJDBC3; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; - -/** - * This class extends AbstractClobFromLobCreatorTest to determine if the - * correct LobCreator impl is used when Environment.USE_CONNECTION_FOR_LOB_CREATION - * is set to false. The actual impl should be the JDBC3 LobCreator, even when - * the JVM and JDBC driver support JDBC4. The JDBC3 LobCreator does not use the - * Connection to create LOBs. - * - * @author Gail Badner - */ -public class ClobFromLobCreatorJDBC3Test extends AbstractClobFromLobCreatorTest { - - public ClobFromLobCreatorJDBC3Test(String name) { - super( name ); - } - - protected Boolean getUseConnectionForLobCreationPropertyValue() { - return Boolean.FALSE; - } - - protected Class getExpectedLobCreatorClass() { - return LobCreatorImplJDBC3.class; - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( ClobFromLobCreatorJDBC3Test.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4ConnRelOnCloseTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4ConnRelOnCloseTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4ConnRelOnCloseTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,54 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import junit.framework.Test; - -import org.hibernate.cfg.Environment; -import org.hibernate.cfg.Configuration; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; - -/** - * This class extends ClobFromLobCreatorJDBC4Test to run tests - * using connection release mode "on_close". - * - * @author Gail Badner - */ -public class ClobFromLobCreatorJDBC4ConnRelOnCloseTest extends ClobFromLobCreatorJDBC4Test { - - public ClobFromLobCreatorJDBC4ConnRelOnCloseTest(String name) { - super( name ); - } - - public void configure(Configuration cfg) { - super.configure( cfg ); - cfg.setProperty( Environment.RELEASE_CONNECTIONS, "on_close" ); - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( ClobFromLobCreatorJDBC4ConnRelOnCloseTest.class ); - } -} \ No newline at end of file Deleted: core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4Test.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4Test.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobFromLobCreatorJDBC4Test.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -1,112 +0,0 @@ -//$Id: $ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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, as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY 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 - * along with this distribution; if not, write to: - * Free Software Foundation, Inc. - * 51 Franklin Street, Fifth Floor - * Boston, MA 02110-1301 USA - * - */ -package org.hibernate.test.lob; - -import java.sql.SQLException; -import java.sql.Clob; - -import junit.framework.Test; - -import org.hibernate.lob.LobCreatorImplJDBC4; -import org.hibernate.cfg.Environment; -import org.hibernate.junit.functional.FunctionalTestClassTestSuite; -import org.hibernate.Session; -import org.hibernate.HibernateException; - -/** - * This class extends AbstractClobFromLobCreatorTest to determine if the - * correct LobCreator impl is used when Environment.USE_CONNECTION_FOR_LOB_CREATION - * is set to true. The actual impl should be the JDBC4 LobCreator, even when - * the JVM and/or JDBC driver do not support JDBC4. The JDBC4 LobCreator uses the - * Connection to create LOBs. - * - * @author Gail Badner - */ -public class ClobFromLobCreatorJDBC4Test extends AbstractClobFromLobCreatorTest { - - public ClobFromLobCreatorJDBC4Test(String name) { - super( name ); - } - - protected Boolean getUseConnectionForLobCreationPropertyValue() { - return Boolean.TRUE; - } - - protected Class getExpectedLobCreatorClass() { - return LobCreatorImplJDBC4.class; - } - - public static Test suite() { - return new FunctionalTestClassTestSuite( ClobFromLobCreatorJDBC4Test.class ); - } - - protected boolean skipLobLocatorTests() throws SQLException { - if ( ! Environment.jvmSupportsJDBC4() ) { - reportSkip( "JVM does not support creating LOBs using the connection", "LOB support" ); - return true; - } - if ( ! jvmAndDriverSupportUseConnectionForLobCreation() ) { - reportSkip( "Driver does not support creating LOBs using the connection", "LOB support" ); - return true; - } - return false; - } - - public void testCreateClobLocatorSupport() throws Throwable { - Session s = openSession(); - s.getTransaction().begin(); - String str = buildRecursively( CLOB_SIZE, 'x' ); - try { - Clob clob = createClobLocator( s, str ); - if ( ! Environment.jvmSupportsJDBC4() ) { - fail( "should have thrown NoSuchMethodException" ); - } - else if ( ! jvmAndDriverSupportUseConnectionForLobCreation() ) { - fail( "should have thrown AbstractMethodException" ); - } - assertEquals( str, extractData( clob ) ); - s.getTransaction().commit(); - } - catch( HibernateException e ) { - s.getTransaction().rollback(); - if ( e.getCause() instanceof NoSuchMethodException ) { - assertTrue( ! Environment.jvmSupportsJDBC4() && - isUseConnectionForLobCreationEnabled() ); - } - else if ( e.getCause() instanceof AbstractMethodError ) { - assertTrue( Environment.jvmSupportsJDBC4() && - ! jvmAndDriverSupportUseConnectionForLobCreation() && - isUseConnectionForLobCreationEnabled() ); - } - else { - throw e; - } - } - finally { - s.close(); - } - } -} \ No newline at end of file Modified: core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobTest.java =================================================================== --- core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobTest.java 2009-03-30 22:36:45 UTC (rev 16232) +++ core/branches/Branch_3_2/test/org/hibernate/test/lob/ClobTest.java 2009-03-31 06:43:12 UTC (rev 16233) @@ -26,37 +26,196 @@ package org.hibernate.test.lob; import java.sql.Clob; -import java.io.IOException; -import java.io.StringReader; import junit.framework.Test; import org.hibernate.Hibernate; +import org.hibernate.LockMode; import org.hibernate.Session; +import org.hibernate.dialect.Dialect; +import org.hibernate.dialect.H2Dialect; +import org.hibernate.junit.functional.DatabaseSpecificFunctionalTestCase; import org.hibernate.junit.functional.FunctionalTestClassTestSuite; /** - * This class extends AbstractClobTest so that LOBs are created using the - * Hibernate.createClob() APIs. These APIs do not use the connection to - * create LOBs. + * Test various access scenarios for eager and lazy materialization + * of CLOB data, as well as bounded and unbounded materialization + * and mutation. * * @author Steve Ebersole */ -public class ClobTest extends AbstractClobTest { +public class ClobTest extends DatabaseSpecificFunctionalTestCase { + private static final int CLOB_SIZE = 10000; public ClobTest(String name) { super( name ); } + public String[] getMappings() { + return new String[] { "lob/LobMappings.hbm.xml" }; + } + public static Test suite() { return new FunctionalTestClassTestSuite( ClobTest.class ); } - protected Clob createClobLocator(Session s, String str) { - return Hibernate.createClob( str ); + public boolean appliesTo(Dialect dialect) { + if ( ! dialect.supportsExpectedLobUsagePattern() ) { + reportSkip( "database/driver does not support expected LOB usage pattern", "LOB support" ); + return false; + } + return true; } - protected Clob createClobLocatorFromStreamUsingLength(Session s, String str) throws IOException { - return Hibernate.createClob( new StringReader( str ), str.length() ); + public void testBoundedMaterializedClobAccess() { + String original = buildRecursively( CLOB_SIZE, 'x' ); + String changed = buildRecursively( CLOB_SIZE, 'y' ); + + Session s = openSession(); + s.beginTransaction(); + LobHolder entity = new LobHolder(); + entity.setMaterializedClob( original ); + s.save( entity ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( CLOB_SIZE, entity.getMaterializedClob().length() ); + assertEquals( original, entity.getMaterializedClob() ); + entity.setMaterializedClob( changed ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( CLOB_SIZE, entity.getMaterializedClob().length() ); + assertEquals( changed, entity.getMaterializedClob() ); + s.delete( entity ); + s.getTransaction().commit(); + s.close(); } -} \ No newline at end of file + + public void testBoundedClobLocatorAccess() throws Throwable { + String original = buildRecursively( CLOB_SIZE, 'x' ); + String changed = buildRecursively( CLOB_SIZE, 'y' ); + + Session s = openSession(); + s.beginTransaction(); + LobHolder entity = new LobHolder(); + entity.setClobLocator( Hibernate.createClob( original ) ); + s.save( entity ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); + assertEquals( original, extractData( entity.getClobLocator() ) ); + s.getTransaction().commit(); + s.close(); + + // test mutation via setting the new clob data... + if ( supportsLobValueChangePropogation() ) { + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); + entity.getClobLocator().truncate( 1 ); + entity.getClobLocator().setString( 1, changed ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); + assertNotNull( entity.getClobLocator() ); + assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); + assertEquals( changed, extractData( entity.getClobLocator() ) ); + entity.getClobLocator().truncate( 1 ); + entity.getClobLocator().setString( 1, original ); + s.getTransaction().commit(); + s.close(); + } + + // test mutation via supplying a new clob locator instance... + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId(), LockMode.UPGRADE ); + assertNotNull( entity.getClobLocator() ); + assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); + assertEquals( original, extractData( entity.getClobLocator() ) ); + entity.setClobLocator( Hibernate.createClob( changed ) ); + s.getTransaction().commit(); + s.close(); + + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); + assertEquals( changed, extractData( entity.getClobLocator() ) ); + s.delete( entity ); + s.getTransaction().commit(); + s.close(); + + } + + public void testUnboundedClobLocatorAccess() throws Throwable { + if ( ! supportsUnboundedLobLocatorMaterialization() ) { + return; + } + + // Note: unbounded mutation of the underlying lob data is completely + // unsupported; most databases would not allow such a construct anyway. + // Thus here we are only testing materialization... + + String original = buildRecursively( CLOB_SIZE, 'x' ); + + Session s = openSession(); + s.beginTransaction(); + LobHolder entity = new LobHolder(); + entity.setClobLocator( Hibernate.createClob( original ) ); + s.save( entity ); + s.getTransaction().commit(); + s.close(); + + // load the entity with the clob locator, and close the session/transaction; + // at that point it is unbounded... + s = openSession(); + s.beginTransaction(); + entity = ( LobHolder ) s.get( LobHolder.class, entity.getId() ); + s.getTransaction().commit(); + s.close(); + + assertEquals( CLOB_SIZE, entity.getClobLocator().length() ); + assertEquals( original, extractData( entity.getClobLocator() ) ); + + s = openSession(); + s.beginTransaction(); + s.delete( entity ); + s.getTransaction().commit(); + s.close(); + } + + private String extractData(Clob clob) throws Throwable { + if ( getDialect() instanceof H2Dialect ) { + return clob.getSubString( 1, ( int ) clob.length() ); + } + else { + char[] data = new char[ (int) clob.length() ]; + clob.getCharacterStream().read( data ); + return new String( data ); + } + } + + + private String buildRecursively(int size, char baseChar) { + StringBuffer buff = new StringBuffer(); + for( int i = 0; i < size; i++ ) { + buff.append( baseChar ); + } + return buff.toString(); + } +}