Fix oracle and mysql issues

Author: maca88

src/NHibernate.Test/NHSpecificTest/GH2029/Fixture.cs

@@ -84,6 +84,9 @@ protected override void OnTearDown()
 		[Test]
 		public void NullableIntOverflow()
 		{
+			var hasCast = Dialect.GetCastTypeName(NHibernateUtil.Int32.SqlType) !=
+			              Dialect.GetCastTypeName(NHibernateUtil.Int64.SqlType);
+
 			using (var session = OpenSession())
 			using (session.BeginTransaction())
 			using (var sqlLog = new SqlLogSpy())
@@ -96,7 +99,7 @@ public void NullableIntOverflow()
 					   })
 					   .ToList();
 
-				Assert.That(FindAllOccurrences(sqlLog.GetWholeLog(), "cast"), Is.EqualTo(1));
+				Assert.That(FindAllOccurrences(sqlLog.GetWholeLog(), "cast"), Is.EqualTo(hasCast ? 1 : 0));
 				Assert.That(groups, Has.Count.EqualTo(1));
 				Assert.That(groups[0].s, Is.EqualTo((long) int.MaxValue * 2));
 			}
@@ -105,6 +108,9 @@ public void NullableIntOverflow()
 		[Test]
 		public void IntOverflow()
 		{
+			var hasCast = Dialect.GetCastTypeName(NHibernateUtil.Int32.SqlType) !=
+			              Dialect.GetCastTypeName(NHibernateUtil.Int64.SqlType);
+
 			using (var session = OpenSession())
 			using (session.BeginTransaction())
 			using (var sqlLog = new SqlLogSpy())
@@ -117,7 +123,7 @@ public void IntOverflow()
 									})
 									.ToList();
 
-				Assert.That(FindAllOccurrences(sqlLog.GetWholeLog(), "cast"), Is.EqualTo(1));
+				Assert.That(FindAllOccurrences(sqlLog.GetWholeLog(), "cast"), Is.EqualTo(hasCast ? 1 : 0));
 				Assert.That(groups, Has.Count.EqualTo(1));
 				Assert.That(groups[0].s, Is.EqualTo((long) int.MaxValue * 3));
 			}

src/NHibernate/Dialect/Dialect.cs

@@ -266,6 +266,18 @@ public virtual string GetLongestTypeName(DbType dbType)
 		public virtual string GetCastTypeName(SqlType sqlType) =>
 			GetCastTypeName(sqlType, _typeNames);
 
+		/// <summary> 
+		/// Get the name of the database type appropriate for casting operations
+		/// (via the CAST() SQL function) for the given <see cref="SqlType"/> typecode.
+		/// </summary>
+		/// <param name="sqlType">The <see cref="SqlType"/> typecode.</param>
+		/// <param name="typeName">The database type name that will be set in case it was found.</param>
+		/// <returns>Whether the type name was found.</returns>
+		public virtual bool TryGetCastTypeName(SqlType sqlType, out string typeName)
+		{
+			return TryGetCastTypeName(sqlType, _typeNames, out typeName);
+		}
+
 		/// <summary> 
 		/// Get the name of the database type appropriate for casting operations
 		/// (via the CAST() SQL function) for the given <see cref="SqlType"/> typecode.
@@ -274,28 +286,46 @@ public virtual string GetCastTypeName(SqlType sqlType) =>
 		/// <param name="castTypeNames">The source for type names.</param>
 		/// <returns>The database type name.</returns>
 		protected virtual string GetCastTypeName(SqlType sqlType, TypeNames castTypeNames)
+		{
+			if (!TryGetCastTypeName(sqlType, castTypeNames, out var result))
+			{
+				throw new ArgumentException("Dialect does not support DbType." + sqlType.DbType, nameof(sqlType));
+			}
+
+			return result;
+		}
+
+		/// <summary> 
+		/// Get the name of the database type appropriate for casting operations
+		/// (via the CAST() SQL function) for the given <see cref="SqlType"/> typecode.
+		/// </summary>
+		/// <param name="sqlType">The <see cref="SqlType"/> typecode.</param>
+		/// <param name="castTypeNames">The source for type names.</param>
+		/// <param name="typeName">The database type name that will be set in case it was found.</param>
+		/// <returns>Whether the type name was found.</returns>
+		protected virtual bool TryGetCastTypeName(SqlType sqlType, TypeNames castTypeNames, out string typeName)
 		{
 			if (sqlType.LengthDefined || sqlType.PrecisionDefined || sqlType.ScaleDefined)
-				return castTypeNames.Get(sqlType.DbType, sqlType.Length, sqlType.Precision, sqlType.Scale);
+				return castTypeNames.TryGet(sqlType.DbType, sqlType.Length, sqlType.Precision, sqlType.Scale, out typeName);
 			switch (sqlType.DbType)
 			{
 				case DbType.Decimal:
 				// Oracle dialect defines precision and scale for double, because it uses number instead of binary_double.
 				case DbType.Double:
 					// We cannot know if the user needs its digit after or before the dot, so use a configurable
 					// default.
-					return castTypeNames.Get(sqlType.DbType, 0, DefaultCastPrecision, DefaultCastScale);
+					return castTypeNames.TryGet(sqlType.DbType, 0, DefaultCastPrecision, DefaultCastScale, out typeName);
 				case DbType.DateTime:
 				case DbType.DateTime2:
 				case DbType.DateTimeOffset:
 				case DbType.Time:
 				case DbType.Currency:
 					// Use default for these, dialects are supposed to map them to max capacity
-					return castTypeNames.Get(sqlType.DbType);
+					return castTypeNames.TryGet(sqlType.DbType, out typeName);
 				default:
 					// Other types are either length bound or not length/precision/scale bound. Otherwise they need to be
 					// handled previously.
-					return castTypeNames.Get(sqlType.DbType, DefaultCastLength, 0, 0);
+					return castTypeNames.TryGet(sqlType.DbType, DefaultCastLength, 0, 0, out typeName);
 			}
 		}
 

src/NHibernate/Dialect/Function/CastFunction.cs

@@ -50,10 +50,9 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 				{
 					throw new QueryException("invalid NHibernate type for cast(), was:" + typeName);
 				}
-				sqlType = factory.Dialect.GetCastTypeName(sqlTypeCodes[0]);
-				if (sqlType == null)
+
+				if (!factory.Dialect.TryGetCastTypeName(sqlTypeCodes[0], out sqlType))
 				{
-					//TODO: never reached, since GetTypeName() actually throws an exception!
 					sqlType = typeName;
 				}
 				//else 

src/NHibernate/Dialect/TypeNames.cs

@@ -57,13 +57,24 @@ public class TypeNames
 		/// <returns>the default type name associated with the specified key</returns>
 		public string Get(DbType typecode)
 		{
-			if (!defaults.TryGetValue(typecode, out var result))
+			if (!TryGet(typecode, out var result))
 			{
 				throw new ArgumentException("Dialect does not support DbType." + typecode, nameof(typecode));
 			}
 			return result;
 		}
 
+		/// <summary>
+		/// Get default type name for specified type.
+		/// </summary>
+		/// <param name="typecode">The type key.</param>
+		/// <param name="typeName">The default type name that will be set in case it was found.</param>
+		/// <returns>Whether the default type name was found.</returns>
+		public bool TryGet(DbType typecode, out string typeName)
+		{
+			return defaults.TryGetValue(typecode, out typeName);
+		}
+
 		/// <summary>
 		/// Get the type name specified type and size
 		/// </summary>
@@ -76,6 +87,28 @@ public string Get(DbType typecode)
 		/// if available, otherwise the default type name.
 		/// </returns>
 		public string Get(DbType typecode, int size, int precision, int scale)
+		{
+			if (!TryGet(typecode, size, precision, scale, out var result))
+			{
+				throw new ArgumentException("Dialect does not support DbType." + typecode, nameof(typecode));
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		/// Get the type name specified type and size.
+		/// </summary>
+		/// <param name="typecode">The type key.</param>
+		/// <param name="size">The SQL length.</param>
+		/// <param name="scale">The SQL scale.</param>
+		/// <param name="precision">The SQL precision.</param>
+		/// <param name="typeName">
+		/// The associated name with smallest capacity >= size (or precision for decimal, or scale for date time types)
+		/// if available, otherwise the default type name.
+		/// </param>
+		/// <returns>Whether the type name was found.</returns>
+		public bool TryGet(DbType typecode, int size, int precision, int scale, out string typeName)
 		{
 			weighted.TryGetValue(typecode, out var map);
 			if (map != null && map.Count > 0)
@@ -88,7 +121,8 @@ public string Get(DbType typecode, int size, int precision, int scale)
 				{
 					if (requiredCapacity <= entry.Key)
 					{
-						return Replace(entry.Value, size, precision, scale);
+						typeName = Replace(entry.Value, size, precision, scale);
+						return true;
 					}
 				}
 				if (isPrecisionType && precision != 0)
@@ -102,11 +136,12 @@ public string Get(DbType typecode, int size, int precision, int scale)
 					// But if the type is used for storing amounts, this may cause losing the ability to store cents...
 					// So better just reduce as few as possible.
 					var adjustedScale = Math.Min(scale, adjustedPrecision);
-					return Replace(maxEntry.Value, size, adjustedPrecision, adjustedScale);
+					typeName = Replace(maxEntry.Value, size, adjustedPrecision, adjustedScale);
+					return true;
 				}
 			}
 			//Could not find a specific type for the capacity, using the default
-			return Get(typecode);
+			return TryGet(typecode, out typeName);
 		}
 
 		/// <summary>

src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs

@@ -243,13 +243,13 @@ constant.Value is CallSite site &&
 		protected HqlTreeNode VisitNhAverage(NhAverageExpression expression)
 		{
 			var hqlExpression = VisitExpression(expression.Expression).AsExpression();
-			hqlExpression = IsCastRequired(expression.Expression, expression.Type)
+			hqlExpression = IsCastRequired(expression.Expression, expression.Type, out _)
 				? (HqlExpression) _hqlTreeBuilder.Cast(hqlExpression, expression.Type)
 				: _hqlTreeBuilder.TransparentCast(hqlExpression, expression.Type);
 
-			return IsCastRequired(expression.Type, "avg")
-				? (HqlTreeNode) _hqlTreeBuilder.Cast(_hqlTreeBuilder.Average(hqlExpression), expression.Type)
-				: _hqlTreeBuilder.TransparentCast(_hqlTreeBuilder.Average(hqlExpression), expression.Type);
+			// In Oracle the avg function can return a number with up to 40 digits which cannot be retrieved from the data reader due to the lack of such
+			// numeric type in .NET. In order to avoid that we have to add a cast to trim the number so that it can be converted into a .NET numeric type.
+			return _hqlTreeBuilder.Cast(_hqlTreeBuilder.Average(hqlExpression), expression.Type);
 		}
 
 		protected HqlTreeNode VisitNhCount(NhCountExpression expression)
@@ -269,7 +269,7 @@ protected HqlTreeNode VisitNhMax(NhMaxExpression expression)
 
 		protected HqlTreeNode VisitNhSum(NhSumExpression expression)
 		{
-			return IsCastRequired(expression.Type, "sum")
+			return IsCastRequired(expression.Type, "sum", out _)
 				? (HqlTreeNode) _hqlTreeBuilder.Cast(_hqlTreeBuilder.Sum(VisitExpression(expression.Expression).AsExpression()), expression.Type)
 				: _hqlTreeBuilder.TransparentCast(_hqlTreeBuilder.Sum(VisitExpression(expression.Expression).AsExpression()), expression.Type);
 		}
@@ -485,9 +485,12 @@ protected HqlTreeNode VisitUnaryExpression(UnaryExpression expression)
 				case ExpressionType.Convert:
 				case ExpressionType.ConvertChecked:
 				case ExpressionType.TypeAs:
-					return IsCastRequired(expression.Operand, expression.Type)
+					return IsCastRequired(expression.Operand, expression.Type, out var existType)
 						? _hqlTreeBuilder.Cast(VisitExpression(expression.Operand).AsExpression(), expression.Type)
-						: VisitExpression(expression.Operand);
+						// Make a transparent cast when an IType exists, so that it can be used to retrieve the value from the data reader
+						: existType
+							? _hqlTreeBuilder.TransparentCast(VisitExpression(expression.Operand).AsExpression(), expression.Type)
+							: VisitExpression(expression.Operand);
 			}
 
 			throw new NotSupportedException(expression.ToString());
@@ -589,63 +592,75 @@ protected HqlTreeNode VisitNewArrayExpression(NewArrayExpression expression)
 			return _hqlTreeBuilder.ExpressionSubTreeHolder(expressionSubTree);
 		}
 
-		private bool IsCastRequired(Expression expression, System.Type toType)
+		private bool IsCastRequired(Expression expression, System.Type toType, out bool existType)
 		{
-			return toType != typeof(object) && IsCastRequired(GetType(expression), TypeFactory.GetDefaultTypeFor(toType));
+			existType = false;
+			return toType != typeof(object) && IsCastRequired(GetType(expression), TypeFactory.GetDefaultTypeFor(toType), out existType);
 		}
 
-		private bool IsCastRequired(IType type, IType toType)
+		private bool IsCastRequired(IType type, IType toType, out bool existType)
 		{
 			// A type can be null when casting an entity into a base class, in that case we should not cast
 			if (type == null || toType == null || Equals(type, toType))
 			{
+				existType = false;
 				return false;
 			}
 
 			var sqlTypes = type.SqlTypes(_parameters.SessionFactory);
 			var toSqlTypes = toType.SqlTypes(_parameters.SessionFactory);
 			if (sqlTypes.Length != 1 || toSqlTypes.Length != 1)
 			{
+				existType = false;
 				return false; // Casting a multi-column type is not possible
 			}
 
+			existType = true;
 			if (sqlTypes[0].DbType == toSqlTypes[0].DbType)
 			{
 				return false;
 			}
 
 			if (type.ReturnedClass.IsEnum && sqlTypes[0].DbType == DbType.String)
 			{
+				existType = false;
 				return false; // Never cast an enum that is mapped as string, the type will provide a string for the parameter value
 			}
 
 			// Some dialects can map several sql types into one, cast only if the dialect types are different
-			var castTypeName = _parameters.SessionFactory.Dialect.GetCastTypeName(sqlTypes[0]);
-			var toCastTypeName = _parameters.SessionFactory.Dialect.GetCastTypeName(toSqlTypes[0]);
+			if (!_parameters.SessionFactory.Dialect.TryGetCastTypeName(sqlTypes[0], out var castTypeName) ||
+			    !_parameters.SessionFactory.Dialect.TryGetCastTypeName(toSqlTypes[0], out var toCastTypeName))
+			{
+				return false; // The dialect does not support such cast
+			}
+
 			return castTypeName != toCastTypeName;
 		}
 
-		private bool IsCastRequired(System.Type type, string sqlFunctionName)
+		private bool IsCastRequired(System.Type type, string sqlFunctionName, out bool existType)
 		{
 			if (type == typeof(object))
 			{
+				existType = false;
 				return false;
 			}
 
 			var toType = TypeFactory.GetDefaultTypeFor(type);
 			if (toType == null)
 			{
+				existType = false;
 				return true; // Fallback to the old behavior
 			}
 
+			existType = true;
 			var sqlFunction = _parameters.SessionFactory.SQLFunctionRegistry.FindSQLFunction(sqlFunctionName);
 			if (sqlFunction == null)
 			{
 				return true; // Fallback to the old behavior
 			}
 
 			var fnReturnType = sqlFunction.ReturnType(toType, _parameters.SessionFactory);
-			return fnReturnType == null || IsCastRequired(fnReturnType, toType);
+			return fnReturnType == null || IsCastRequired(fnReturnType, toType, out existType);
 		}
 
 		private IType GetType(Expression expression)