HHH-7889 Cleanup inconsistencies in Blob, Clob, and NClob type

descriptors

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/ClobTypeDescriptor.java

@@ -23,14 +23,19 @@
  */
 package org.hibernate.type.descriptor.java;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
 import java.io.Serializable;
 import java.sql.Clob;
+import java.sql.SQLException;
 import java.util.Comparator;
 
+import org.hibernate.HibernateException;
+import org.hibernate.engine.jdbc.CharacterStream;
 import org.hibernate.engine.jdbc.ClobImplementer;
 import org.hibernate.engine.jdbc.ClobProxy;
 import org.hibernate.engine.jdbc.WrappedClob;
-import org.hibernate.engine.jdbc.CharacterStream;
 import org.hibernate.engine.jdbc.internal.CharacterStreamImpl;
 import org.hibernate.type.descriptor.WrapperOptions;
 
@@ -95,29 +100,33 @@ public class ClobTypeDescriptor extends AbstractTypeDescriptor<Clob> {
 
 	@SuppressWarnings({ "unchecked" })
 	public <X> X unwrap(final Clob value, Class<X> type, WrapperOptions options) {
-		if ( ! ( Clob.class.isAssignableFrom( type ) || CharacterStream.class.isAssignableFrom( type ) ) ) {
-			throw unknownUnwrap( type );
-		}
-
 		if ( value == null ) {
 			return null;
 		}
 
-		if ( CharacterStream.class.isAssignableFrom( type ) ) {
+		try {
-			if ( ClobImplementer.class.isInstance( value ) ) {
+			if ( CharacterStream.class.isAssignableFrom( type ) ) {
-				// if the incoming Clob is a wrapper, just pass along its CharacterStream
+				if ( ClobImplementer.class.isInstance( value ) ) {
-				return (X) ( (ClobImplementer) value ).getUnderlyingStream();
+					// if the incoming Clob is a wrapper, just pass along its BinaryStream
+					return (X) ( (ClobImplementer) value ).getUnderlyingStream();
+				}
+				else {
+					// otherwise we need to build a BinaryStream...
+					return (X) new CharacterStreamImpl( DataHelper.extractString( value.getCharacterStream() ) );
+				}
 			}
-			else {
+			else if (Clob.class.isAssignableFrom( type )) {
-				// otherwise we need to build one...
+				final Clob clob =  WrappedClob.class.isInstance( value )
-				return (X) new CharacterStreamImpl( DataHelper.extractString( value ) );
+						? ( (WrappedClob) value ).getWrappedClob()
+						: value;
+				return (X) clob;
 			}
 		}
-
+		catch ( SQLException e ) {
-		final Clob clob =  WrappedClob.class.isInstance( value )
+			throw new HibernateException( "Unable to access clob stream", e );
-				? ( (WrappedClob) value ).getWrappedClob()
+		}
-				: value;
+		
-		return (X) clob;
+		throw unknownUnwrap( type );
 	}
 
 	public <X> Clob wrap(X value, WrapperOptions options) {
@@ -125,10 +134,16 @@ public class ClobTypeDescriptor extends AbstractTypeDescriptor<Clob> {
 			return null;
 		}
 
-		if ( ! Clob.class.isAssignableFrom( value.getClass() ) ) {
+		// Support multiple return types from
-			throw unknownWrap( value.getClass() );
+		// org.hibernate.type.descriptor.sql.ClobTypeDescriptor
+		if ( Clob.class.isAssignableFrom( value.getClass() ) ) {
+			return options.getLobCreator().wrap( (Clob) value );
+		}
+		else if ( Reader.class.isAssignableFrom( value.getClass() ) ) {
+			Reader reader = (Reader) value;
+			return options.getLobCreator().createClob( DataHelper.extractString( reader ) );
 		}
 
-		return options.getLobCreator().wrap( (Clob) value );
+		throw unknownWrap( value.getClass() );
 	}
 }

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/NClobTypeDescriptor.java

@@ -23,10 +23,13 @@
  */
 package org.hibernate.type.descriptor.java;
 
+import java.io.Reader;
 import java.io.Serializable;
 import java.sql.NClob;
+import java.sql.SQLException;
 import java.util.Comparator;
 
+import org.hibernate.HibernateException;
 import org.hibernate.engine.jdbc.CharacterStream;
 import org.hibernate.engine.jdbc.NClobImplementer;
 import org.hibernate.engine.jdbc.NClobProxy;
@@ -95,29 +98,33 @@ public class NClobTypeDescriptor extends AbstractTypeDescriptor<NClob> {
 
 	@SuppressWarnings({ "unchecked" })
 	public <X> X unwrap(final NClob value, Class<X> type, WrapperOptions options) {
-		if ( ! ( NClob.class.isAssignableFrom( type ) || CharacterStream.class.isAssignableFrom( type ) ) ) {
-			throw unknownUnwrap( type );
-		}
-
 		if ( value == null ) {
 			return null;
 		}
 
-		if ( CharacterStream.class.isAssignableFrom( type ) ) {
+		try {
-			if ( NClobImplementer.class.isInstance( value ) ) {
+			if ( CharacterStream.class.isAssignableFrom( type ) ) {
-				// if the incoming Clob is a wrapper, just pass along its CharacterStream
+				if ( NClobImplementer.class.isInstance( value ) ) {
-				return (X) ( (NClobImplementer) value ).getUnderlyingStream();
+					// if the incoming NClob is a wrapper, just pass along its BinaryStream
+					return (X) ( (NClobImplementer) value ).getUnderlyingStream();
+				}
+				else {
+					// otherwise we need to build a BinaryStream...
+					return (X) new CharacterStreamImpl( DataHelper.extractString( value.getCharacterStream() ) );
+				}
 			}
-			else {
+			else if (NClob.class.isAssignableFrom( type )) {
-				// otherwise we need to build one...
+				final NClob nclob =  WrappedNClob.class.isInstance( value )
-				return (X) new CharacterStreamImpl( DataHelper.extractString( value ) );
+						? ( (WrappedNClob) value ).getWrappedNClob()
+						: value;
+				return (X) nclob;
 			}
 		}
-
+		catch ( SQLException e ) {
-		final NClob clob =  WrappedNClob.class.isInstance( value )
+			throw new HibernateException( "Unable to access nclob stream", e );
-				? ( (WrappedNClob) value ).getWrappedNClob()
+		}
-				: value;
+		
-		return (X) clob;
+		throw unknownUnwrap( type );
 	}
 
 	public <X> NClob wrap(X value, WrapperOptions options) {
@@ -125,10 +132,16 @@ public class NClobTypeDescriptor extends AbstractTypeDescriptor<NClob> {
 			return null;
 		}
 
-		if ( ! NClob.class.isAssignableFrom( value.getClass() ) ) {
+		// Support multiple return types from
-			throw unknownWrap( value.getClass() );
+		// org.hibernate.type.descriptor.sql.ClobTypeDescriptor
+		if ( NClob.class.isAssignableFrom( value.getClass() ) ) {
+			return options.getLobCreator().wrap( (NClob) value );
+		}
+		else if ( Reader.class.isAssignableFrom( value.getClass() ) ) {
+			Reader reader = (Reader) value;
+			return options.getLobCreator().createNClob( DataHelper.extractString( reader ) );
 		}
 
-		return options.getLobCreator().wrap( (NClob) value );
+		throw unknownWrap( value.getClass() );
 	}
 }

hibernate-core/src/main/java/org/hibernate/type/descriptor/sql/BlobTypeDescriptor.java

@@ -96,27 +96,27 @@ public abstract class BlobTypeDescriptor implements SqlTypeDescriptor {
 				@Override
                 public <X> BasicExtractor<X> getBlobExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
 					return new BasicExtractor<X>( javaTypeDescriptor, this ) {
-						// For now, default to using getBlob.  If extraction
-						// should also check useStreamForLobBinding, add
-						// checks here and use STREAM_BINDING.
-						
 						@Override
 						protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
-							return BLOB_BINDING.getExtractor( javaTypeDescriptor ).doExtract( rs, name, options );
+							return getBinding( options ).getExtractor( javaTypeDescriptor ).doExtract( rs, name, options );
 						}
 
 						@Override
 						protected X doExtract(CallableStatement statement, int index, WrapperOptions options) throws SQLException {
-							return BLOB_BINDING.getExtractor( javaTypeDescriptor ).doExtract( statement, index, options );
+							return getBinding( options ).getExtractor( javaTypeDescriptor ).doExtract( statement, index, options );
 						}
 
 						@Override
 						protected X doExtract(CallableStatement statement, String name, WrapperOptions options) throws SQLException {
-							return BLOB_BINDING.getExtractor( javaTypeDescriptor ).doExtract( statement, name, options );
+							return getBinding( options ).getExtractor( javaTypeDescriptor ).doExtract( statement, name, options );
 						}
 					};
 				}
 			};
+			
+	private static final BlobTypeDescriptor getBinding( WrapperOptions options ) {
+		return options.useStreamForLobBinding() ? STREAM_BINDING : BLOB_BINDING;
+	}
 
 	public static final BlobTypeDescriptor PRIMITIVE_ARRAY_BINDING =
 			new BlobTypeDescriptor() {

hibernate-core/src/main/java/org/hibernate/type/descriptor/sql/ClobTypeDescriptor.java

@@ -52,6 +52,20 @@ public abstract class ClobTypeDescriptor implements SqlTypeDescriptor {
 	public boolean canBeRemapped() {
 		return true;
 	}
+	
+    protected abstract <X> BasicExtractor<X> getClobExtractor(JavaTypeDescriptor<X> javaTypeDescriptor);
+	
+    @Override
+    public <X> ValueExtractor<X> getExtractor(JavaTypeDescriptor<X> javaTypeDescriptor) {
+        return getClobExtractor( javaTypeDescriptor );
+    }
+
+	protected abstract <X> BasicBinder<X> getClobBinder(JavaTypeDescriptor<X> javaTypeDescriptor);
+
+	@Override
+    public <X> ValueBinder<X> getBinder(JavaTypeDescriptor<X> javaTypeDescriptor) {
+		return getClobBinder( javaTypeDescriptor );
+	}
 
 
 	public static final ClobTypeDescriptor DEFAULT =
@@ -65,12 +79,7 @@ public abstract class ClobTypeDescriptor implements SqlTypeDescriptor {
 					return new BasicBinder<X>( javaTypeDescriptor, this ) {
 						@Override
 						protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options) throws SQLException {
-							if ( options.useStreamForLobBinding() ) {
+							getBinding( options ).getClobBinder( javaTypeDescriptor ).doBind( st, value, index, options );
-								STREAM_BINDING.getClobBinder( javaTypeDescriptor ).doBind( st, value, index, options );
-							}
-							else {
-								CLOB_BINDING.getClobBinder( javaTypeDescriptor ).doBind( st, value, index, options );
-							}
 						}
 					};
 				}
@@ -80,16 +89,27 @@ public abstract class ClobTypeDescriptor implements SqlTypeDescriptor {
 				    return new BasicExtractor<X>( javaTypeDescriptor, this ) {
 				        @Override
 				        protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
-                            if ( options.useStreamForLobBinding() ) {
+				        	return getBinding( options ).getClobExtractor( javaTypeDescriptor ).doExtract( rs, name, options );
-                                return STREAM_BINDING.getClobExtractor( javaTypeDescriptor ).doExtract( rs, name, options );
-                            }
-                            else {
-                                return CLOB_BINDING.getClobExtractor( javaTypeDescriptor ).doExtract( rs, name, options );
-                            }
 				        }
+
+						@Override
+						protected X doExtract(CallableStatement statement, int index, WrapperOptions options)
+								throws SQLException {
+							return getBinding( options ).getClobExtractor( javaTypeDescriptor ).doExtract( statement, index, options );
+						}
+
+						@Override
+						protected X doExtract(CallableStatement statement, String name, WrapperOptions options)
+								throws SQLException {
+							return getBinding( options ).getClobExtractor( javaTypeDescriptor ).doExtract( statement, name, options );
+						}
                     };
 				}
 			};
+			
+	private static final ClobTypeDescriptor getBinding( WrapperOptions options ) {
+		return options.useStreamForLobBinding() ? STREAM_BINDING : CLOB_BINDING;
+	}
 
 	public static final ClobTypeDescriptor CLOB_BINDING =
 			new ClobTypeDescriptor() {
@@ -112,6 +132,18 @@ public abstract class ClobTypeDescriptor implements SqlTypeDescriptor {
                         protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
                             return javaTypeDescriptor.wrap( rs.getClob( name ), options );
                         }
+
+						@Override
+						protected X doExtract(CallableStatement statement, int index, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getClob( index ), options );
+						}
+
+						@Override
+						protected X doExtract(CallableStatement statement, String name, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getClob( name ), options );
+						}
 				        
                     };
 				};
@@ -139,23 +171,21 @@ public abstract class ClobTypeDescriptor implements SqlTypeDescriptor {
                         protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
                             return javaTypeDescriptor.wrap( rs.getCharacterStream( name ), options );
                         }
+
+						@Override
+						protected X doExtract(CallableStatement statement, int index, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getCharacterStream( index ), options );
+						}
+
+						@Override
+						protected X doExtract(CallableStatement statement, String name, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getCharacterStream( name ), options );
+						}
                         
                     };
                 };
 			};
 
-	protected abstract <X> BasicBinder<X> getClobBinder(JavaTypeDescriptor<X> javaTypeDescriptor);
-	
-    protected abstract <X> BasicExtractor<X> getClobExtractor(JavaTypeDescriptor<X> javaTypeDescriptor);
-
-	@Override
-    public <X> ValueBinder<X> getBinder(JavaTypeDescriptor<X> javaTypeDescriptor) {
-		return getClobBinder( javaTypeDescriptor );
-	}
-	
-    @Override
-    public <X> ValueExtractor<X> getExtractor(JavaTypeDescriptor<X> javaTypeDescriptor) {
-        return getClobExtractor( javaTypeDescriptor );
-    }
-
 }

hibernate-core/src/main/java/org/hibernate/type/descriptor/sql/NClobTypeDescriptor.java

@@ -52,58 +52,69 @@ public abstract class NClobTypeDescriptor implements SqlTypeDescriptor {
 	public boolean canBeRemapped() {
 		return true;
 	}
+	
+    protected abstract <X> BasicExtractor<X> getNClobExtractor(JavaTypeDescriptor<X> javaTypeDescriptor);
+	
+    @Override
+    public <X> ValueExtractor<X> getExtractor(JavaTypeDescriptor<X> javaTypeDescriptor) {
+        return getNClobExtractor( javaTypeDescriptor );
+    }
+
+	protected abstract <X> BasicBinder<X> getNClobBinder(JavaTypeDescriptor<X> javaTypeDescriptor);
 
 	@Override
-	public <X> ValueExtractor<X> getExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+    public <X> ValueBinder<X> getBinder(JavaTypeDescriptor<X> javaTypeDescriptor) {
-		return new BasicExtractor<X>( javaTypeDescriptor, this ) {
+		return getNClobBinder( javaTypeDescriptor );
-			@Override
-			protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
-				return javaTypeDescriptor.wrap( rs.getNClob( name ), options );
-			}
-
-			@Override
-			protected X doExtract(CallableStatement statement, int index, WrapperOptions options) throws SQLException {
-				return javaTypeDescriptor.wrap( statement.getNClob( index ), options );
-			}
-
-			@Override
-			protected X doExtract(CallableStatement statement, String name, WrapperOptions options) throws SQLException {
-				return javaTypeDescriptor.wrap( statement.getNClob( name ), options );
-			}
-		};
 	}
 
 
-	protected abstract <X> BasicBinder<X> getClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor);
+	public static final NClobTypeDescriptor DEFAULT =
-
+			new NClobTypeDescriptor() {
-	public <X> ValueBinder<X> getBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
-		return getClobBinder( javaTypeDescriptor );
-	}
-
-	public static final ClobTypeDescriptor DEFAULT =
-			new ClobTypeDescriptor() {
 				{
 					SqlTypeDescriptorRegistry.INSTANCE.addDescriptor( this );
 				}
 
-				public <X> BasicBinder<X> getClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+				@Override
+                public <X> BasicBinder<X> getNClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
 					return new BasicBinder<X>( javaTypeDescriptor, this ) {
 						@Override
 						protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options) throws SQLException {
-							if ( options.useStreamForLobBinding() ) {
+							getBinding( options ).getNClobBinder( javaTypeDescriptor ).doBind( st, value, index, options );
-								STREAM_BINDING.getClobBinder( javaTypeDescriptor ).doBind( st, value, index, options );
-							}
-							else {
-								CLOB_BINDING.getClobBinder( javaTypeDescriptor ).doBind( st, value, index, options );
-							}
 						}
 					};
 				}
-			};
+				
+				@Override
+				public <X> BasicExtractor<X> getNClobExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+				    return new BasicExtractor<X>( javaTypeDescriptor, this ) {
+				        @Override
+				        protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
+				        	return getBinding( options ).getNClobExtractor( javaTypeDescriptor ).doExtract( rs, name, options );
+				        }
 
-	public static final ClobTypeDescriptor CLOB_BINDING =
+						@Override
-			new ClobTypeDescriptor() {
+						protected X doExtract(CallableStatement statement, int index, WrapperOptions options)
-				public <X> BasicBinder<X> getClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+								throws SQLException {
+							return getBinding( options ).getNClobExtractor( javaTypeDescriptor ).doExtract( statement, index, options );
+						}
+
+						@Override
+						protected X doExtract(CallableStatement statement, String name, WrapperOptions options)
+								throws SQLException {
+							return getBinding( options ).getNClobExtractor( javaTypeDescriptor ).doExtract( statement, name, options );
+						}
+                    };
+				}
+			};
+			
+	private static final NClobTypeDescriptor getBinding( WrapperOptions options ) {
+		return options.useStreamForLobBinding() ? STREAM_BINDING : NCLOB_BINDING;
+	}
+
+	public static final NClobTypeDescriptor NCLOB_BINDING =
+			new NClobTypeDescriptor() {
+				@Override
+                public <X> BasicBinder<X> getNClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
 					return new BasicBinder<X>( javaTypeDescriptor, this ) {
 						@Override
 						protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options)
@@ -112,11 +123,36 @@ public abstract class NClobTypeDescriptor implements SqlTypeDescriptor {
 						}
 					};
 				}
+				
+				@Override
+                public <X> BasicExtractor<X> getNClobExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+				    return new BasicExtractor<X>(javaTypeDescriptor, this) {
+
+                        @Override
+                        protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
+                            return javaTypeDescriptor.wrap( rs.getNClob( name ), options );
+                        }
+
+						@Override
+						protected X doExtract(CallableStatement statement, int index, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getNClob( index ), options );
+						}
+
+						@Override
+						protected X doExtract(CallableStatement statement, String name, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getNClob( name ), options );
+						}
+				        
+                    };
+				};
 			};
 
-	public static final ClobTypeDescriptor STREAM_BINDING =
+	public static final NClobTypeDescriptor STREAM_BINDING =
-			new ClobTypeDescriptor() {
+			new NClobTypeDescriptor() {
-				public <X> BasicBinder<X> getClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+				@Override
+                public <X> BasicBinder<X> getNClobBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
 					return new BasicBinder<X>( javaTypeDescriptor, this ) {
 						@Override
 						protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options)
@@ -126,5 +162,29 @@ public abstract class NClobTypeDescriptor implements SqlTypeDescriptor {
 						}
 					};
 				}
+                
+                @Override
+                public <X> BasicExtractor<X> getNClobExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
+                    return new BasicExtractor<X>(javaTypeDescriptor, this) {
+
+                        @Override
+                        protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException {
+                            return javaTypeDescriptor.wrap( rs.getCharacterStream( name ), options );
+                        }
+
+						@Override
+						protected X doExtract(CallableStatement statement, int index, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getCharacterStream( index ), options );
+						}
+
+						@Override
+						protected X doExtract(CallableStatement statement, String name, WrapperOptions options)
+								throws SQLException {
+							return javaTypeDescriptor.wrap( statement.getCharacterStream( name ), options );
+						}
+                        
+                    };
+                };
 			};
 }