Initial test for fixing issue #41

Author: rhuijben

src/RepoDb.PostgreSql/DbHelpers/PostgreSqlDbHelper.cs

@@ -284,6 +284,12 @@ private static void HandleDbParameterPostCreation(NpgsqlParameter parameter)
             }
             else if (MaybeUpdateNpgsqlParameterCallback?.Invoke(ref value, np) == true)
                 return value;
+#if NET
+            else if (value is Half h)
+                return (float)h; // Npgsql doesn't support Half, so convert to float
+#endif
+            else if (value is IFormattable)
+                return value; // Don't fall through for this case
         }
 
         return base.ParameterValueToDb(value, parameter);

src/RepoDb/Extensions/DbCommandExtension.cs

@@ -10,6 +10,7 @@
 using RepoDb.Exceptions;
 using RepoDb.Interfaces;
 using RepoDb.Options;
+using RepoDb.Reflection;
 using RepoDb.Resolvers;
 
 namespace RepoDb.Extensions;
@@ -706,7 +707,7 @@ private static bool AutomaticConvert(DbField? dbField,
         return false;
 
 
-        static object? AutomaticConvert(object? value, Type fromType, Type targetType)
+        static object? AutomaticConvert(object value, Type fromType, Type targetType)
         {
             if (fromType == null || targetType == null || fromType == targetType)
             {
@@ -773,7 +774,7 @@ private static bool AutomaticConvert(DbField? dbField,
                 return parser.Invoke(null, [value as string, CultureInfo.InvariantCulture]);
             }
 #if NET
-            else if (targetType == typeof(Half))
+            else if (targetType == typeof(Half) && fromType.IsBinaryIntFloatOrDecimal())
             {
                 return (Half?)(float?)Convert.ChangeType(value, typeof(float), CultureInfo.InvariantCulture);
             }
@@ -790,14 +791,24 @@ private static bool AutomaticConvert(DbField? dbField,
             {
                 return value;
             }
-
-            try
+            else if (Compiler.TryConvertViaProvider(value, targetType, fromType, out var newValue))
             {
-                return Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture);
+                return newValue;
+            }
+            else if (value is IConvertible)
+            {
+                try
+                {
+                    return Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture);
+                }
+                catch (InvalidCastException e)
+                {
+                    throw new InvalidCastException($"While converting from {value?.GetType().FullName} to {targetType.FullName}: " + e.Message, e);
+                }
             }
-            catch (InvalidCastException e)
+            else
             {
-                throw new InvalidCastException($"While converting from {value?.GetType().FullName} to {targetType.FullName}: " + e.Message, e);
+                return value;
             }
         }
     }

src/RepoDb/Reflection/Compiler.cs

@@ -931,7 +931,7 @@ Expression ConvertExpressionToSystemConvertExpression()
                 result = Expression.Call(result, numberFormatMethod, [Expression.Constant(CultureInfo.InvariantCulture, typeof(IFormatProvider))]);
             }
 #if NET
-            else if (toType == typeof(Half))
+            else if (toType == typeof(Half) && (underlyingFromType.IsBinaryIntFloatOrDecimal() || underlyingFromType == StaticType.Object))
             {
                 // System.Converter doesn't support half, nor does 99% of DotNet. Just fall through to float/single support and convert from there
 
@@ -965,17 +965,16 @@ Expression ConvertExpressionToSystemConvertExpression()
                 result = Expression.Condition(
                     Expression.TypeIs(expression, underlyingToType),
                     // This case happens in PostgreSql bulktests
-                    Expression.Convert(expression, underlyingToType),
-                    // And this case is currently not triggered in tests. Ultimate fallback but **SLOW** as it does runtime reflection. Not compiletime
-                    Expression.Convert(
-                        Expression.Call(systemChangeType,
-                        [
-                            ConvertExpressionToTypeExpression(result, StaticType.Object),
-                            Expression.Constant(fromType, typeof(Type)),
-                            Expression.Constant(underlyingToType, typeof(Type)),
-                        ]),
-                        underlyingToType)
-                    );
+                    Expression.Convert(expression, typeof(object)),
+                    // And this currently doesn't happen in tests, but hard failing because IConverable doesn't support types causes quite some issues
+                    Expression.Call(systemChangeType,
+                    [
+                        ConvertExpressionToTypeExpression(result, StaticType.Object),
+                        Expression.Constant(fromType, typeof(Type)),
+                        Expression.Constant(underlyingToType, typeof(Type)),
+                    ])
+                );
+
             }
 
             // Do we need manual NULL handling?
@@ -1011,13 +1010,15 @@ Expression ConvertExpressionToSystemConvertExpression()
 
         try
         {
-            if (actualType is { } && ProviderSpecificTransforms.TryGetValue((actualType, conversionType), out var metaTransform)
-                && Expression.Parameter(actualType) is { } param
-                && metaTransform(param) is { } transform)
+            if (actualType is { } && Compiler.TryConvertViaProvider(value, conversionType, actualType, out var newValue))
             {
-                return Expression.Lambda(transform, param).Compile(true).DynamicInvoke(value);
+                return newValue;
             }
-            return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
+
+            if (value is IConvertible) // Convert.ChangeType only supports system types that support IConvertable
+                return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
+            else
+                return value; // We can't convert it... fall through to the db provider, etc.
         }
         catch (Exception ex)
         {
@@ -1028,6 +1029,22 @@ static InvalidOperationException MakeException(Type? valueType, Type conversionT
             => new InvalidOperationException($"No declared converter found to convert value of type '{valueType?.FullName ?? "null"}' (declared as'{fromType.FullName}') to type '{conversionType.FullName}', even via final reflection fallback.", innerException);
     }
 
+    internal static bool TryConvertViaProvider(object value, Type toType, Type valueType, out object? newValue)
+    {
+        // Perhaps the DB provider can do something smart here...
+        if (ProviderSpecificTransforms.TryGetValue((valueType, toType), out var metaTransform)
+            && Expression.Parameter(valueType) is { } param
+            && metaTransform(param) is { } transform)
+        {
+            newValue = Expression.Lambda(transform, param).Compile(true).DynamicInvoke(value);
+            return true;
+        }
+        else
+        {
+            newValue = null;
+            return false;
+        }
+    }
 
     private static Expression ConvertExpressionToPropertyHandlerGetExpression(Expression expression,
         Expression readerExpression,