Merge pull request #1184 from rhuijben/feat/full-DateOnly-support

Add full DateOnly support

Author: mikependon

RepoDb.Core/RepoDb/Extensions/DbCommandExtension.cs

@@ -885,6 +885,12 @@ private static object AutomaticConvert(object value,
             {
                 return AutomaticConvertGuidToString(value);
             }
+#if NET6_0_OR_GREATER
+            else if (fromType == StaticType.DateOnly && targetType == StaticType.DateTime)
+            {
+                return AutomaticConvertDateOnlyToDateTime(value);
+            }
+#endif
             else
             {
                 return (value != DBNull.Value) ? Convert.ChangeType(value, targetType) : Activator.CreateInstance(targetType);
@@ -915,6 +921,10 @@ private static object AutomaticConvertStringToGuid(object value)
         private static object AutomaticConvertGuidToString(object value) =>
             value?.ToString();
 
+#if NET6_0_OR_GREATER
+        private static object AutomaticConvertDateOnlyToDateTime(object value) =>
+            (value is DateOnly dateOnly ? dateOnly.ToDateTime(default(TimeOnly)) : null);
+#endif
         #endregion
     }
 }

RepoDb.Core/RepoDb/Extensions/ExpressionExtension.cs

@@ -382,7 +382,7 @@ public static object GetValue(this NewExpression expression)
             if (expression.Arguments.Count > 0)
             {
                 return Activator.CreateInstance(expression.Type,
-                    expression.Arguments.Select(arg => arg.GetValue()));
+                    expression.Arguments.Select(arg => arg.GetValue()).ToArray());
             }
             else
             {

RepoDb.Core/RepoDb/Reflection/Compiler/Compiler.cs

@@ -1,15 +1,15 @@
+using RepoDb.Enumerations;
+using RepoDb.Exceptions;
+using RepoDb.Extensions;
+using RepoDb.Interfaces;
+using RepoDb.Resolvers;
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
-using RepoDb.Enumerations;
-using RepoDb.Exceptions;
-using RepoDb.Extensions;
-using RepoDb.Interfaces;
-using RepoDb.Resolvers;
 
 namespace RepoDb.Reflection
 {
@@ -510,7 +510,15 @@ internal static MethodInfo GetDateTimeTimeOfDayPropertyGetMethod() =>
         /// <returns></returns>
         internal static MethodInfo GetDateOnlyFromDateTimeStaticMethod() =>
             StaticType.DateOnly.GetMethod("FromDateTime");
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        internal static MethodInfo GetDateTimeFromDateOnlyMethod() =>
+            StaticType.DateOnly.GetMethod("ToDateTime", new Type[] { StaticType.TimeOnly });
 #endif
+
         /// <summary>
         ///
         /// </summary>
@@ -548,6 +556,24 @@ internal static Expression ConvertExpressionToNullableGetValueOrDefaultExpressio
             return expression;
         }
 
+#if NET6_0_OR_GREATER
+        internal static Expression ConvertExpressionToNullableGetValueOrDefaultExpression(Func<Expression, Expression> converter, Expression expression)
+        {
+            if (Nullable.GetUnderlyingType(expression.Type) != null)
+            {
+                var converted = converter(ConvertExpressionToNullableGetValueOrDefaultExpression(expression));
+                var nullableType = typeof(Nullable<>).MakeGenericType(converted.Type);
+                return Expression.Condition(
+                    Expression.Property(expression, nameof(Nullable<int>.HasValue)),
+                    Expression.Convert(converted, nullableType),
+                    Expression.Constant(null, nullableType)
+                );
+            }
+
+            return converter(expression);
+        }
+#endif
+
         /// <summary>
         ///
         /// </summary>
@@ -601,7 +627,15 @@ internal static Expression ConvertExpressionToDateTimeToTimeSpanExpression(Expre
         /// <param name="expression"></param>
         /// <returns></returns>
         internal static Expression ConvertExpressionToDateTimeToDateOnlyExpression(Expression expression) =>
-            ConvertExpressionToNullableGetValueOrDefaultExpression(ConvertExpressionToDateOnlyFromDateTimeExpression(expression));
+            ConvertExpressionToNullableGetValueOrDefaultExpression(ConvertExpressionToDateTimeFromDateOnlyExpression, expression);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        internal static Expression ConvertExpressionToDateOnlyToDateTimeExpression(Expression expression) =>
+            ConvertExpressionToNullableGetValueOrDefaultExpression(ConvertExpressionToDateOnlyFromDateTimeExpression, expression);
 #endif
         /// <summary>
         ///
@@ -625,6 +659,14 @@ internal static Expression ConvertExpressionToDateTimeTimeOfDayExpression(Expres
         /// <param name="expression"></param>
         /// <returns></returns>
         internal static Expression ConvertExpressionToDateOnlyFromDateTimeExpression(Expression expression) =>
+            Expression.Call(expression, GetDateTimeFromDateOnlyMethod(), Expression.Constant(default(TimeOnly)));
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        internal static Expression ConvertExpressionToDateTimeFromDateOnlyExpression(Expression expression) =>
             Expression.Call(null, GetDateOnlyFromDateTimeStaticMethod(), expression);
 #endif
         /// <summary>
@@ -907,6 +949,12 @@ internal static Expression ConvertExpressionWithAutomaticConversion(Expression e
             {
                 expression = ConvertExpressionToDateTimeToDateOnlyExpression(expression);
             }
+
+            // DateOnly to DateTime
+            else if (fromType == StaticType.DateOnly && toType == StaticType.DateTime)
+            {
+                expression = ConvertExpressionToDateOnlyToDateTimeExpression(expression);
+            }
 #endif
             // Others
             else
@@ -1084,7 +1132,7 @@ internal static Expression ConvertExpressionToClassHandlerSetExpression(Expressi
             return entityOrEntitiesExpression;
         }
 
-#endregion
+        #endregion
 
         #region Common
 

RepoDb.SqlServer/RepoDb.SqlServer.IntegrationTests/AdditionalDbTypesTests.cs

@@ -0,0 +1,100 @@
+using Microsoft.Data.SqlClient;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using RepoDb.SqlServer.IntegrationTests.Setup;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace RepoDb.SqlServer.IntegrationTests
+{
+    [TestClass]
+    public class AdditionalDbTypesTests
+    {
+        [TestInitialize]
+        public void Initialize()
+        {
+            GlobalConfiguration
+                .Setup(new()
+                {
+                    ConversionType = Enumerations.ConversionType.Automatic
+                })
+                .UseSqlServer();
+
+            Database.Initialize();
+            Cleanup();
+
+            using var connection = new SqlConnection(Database.ConnectionString).EnsureOpen();
+
+            connection.ExecuteNonQuery($@"
+                IF (NOT EXISTS(SELECT 1 FROM [sys].[objects] WHERE type = 'U' AND name = '{nameof(DateOnlyTestData)}'))
+                BEGIN
+                    CREATE TABLE [dbo].[{nameof(DateOnlyTestData)}] (
+                        [Id] INT IDENTITY(1, 1),
+                        [DateOnly]              DATE NOT NULL,
+                        [DateOnlyNullable]      DATE NULL,
+                        CONSTRAINT [{nameof(DateOnlyTestData)}_Id] PRIMARY KEY 
+		                (
+			                [Id] ASC
+		                )
+                    ) ON [PRIMARY]
+                END");
+
+            // Do this again as this is now overwritten
+            GlobalConfiguration
+                .Setup(new()
+                {
+                    ConversionType = Enumerations.ConversionType.Automatic
+                })
+                .UseSqlServer();
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            Database.Cleanup();
+        }
+
+        [TestMethod]
+        public async Task TestDateTimeOnlyInsertQuery()
+        {
+            await using var connection = new SqlConnection(Database.ConnectionString);
+            await connection.OpenAsync();
+            await using var t = await connection.BeginTransactionAsync();
+
+            await connection.InsertAllAsync(
+                new DateOnlyTestData[] {
+                    new()
+                    {
+                        DateOnly = new DateOnly(2024,1,1),
+                        DateOnlyNullable = null,
+                    },
+                    new ()
+                    {
+                        DateOnly = new DateOnly(2025,1,1),
+                        DateOnlyNullable = new DateOnly(2026,1,1),
+                    }
+                },
+                transaction: t);
+
+
+            var all = await connection.QueryAllAsync<DateOnlyTestData>(transaction: t);
+
+            Assert.IsTrue(all.Any(x => x.DateOnly == new DateOnly(2024, 1, 1)), "Found DateOnly");
+            Assert.IsTrue(all.Any(x => x.DateOnlyNullable == new DateOnly(2026, 1, 1)), "Found nullable DateOnly");
+            Assert.IsTrue(all.Any(x => x.DateOnlyNullable == null), "Found null DateOnly?");
+
+            var cmp1 = new DateOnly(2024, 1, 1);
+            Assert.AreEqual(1, (await connection.QueryAsync<DateOnlyTestData>(where: x => x.DateOnly == cmp1, transaction: t)).Count());
+            Assert.IsTrue((await connection.QueryAsync<DateOnlyTestData>(where: x => x.DateOnlyNullable == new DateOnly(2026, 1, 1), transaction: t)).Count() == 1);
+        }
+
+
+
+        public class DateOnlyTestData
+        {
+            public int ID { get; set; }
+            public DateOnly DateOnly { get; set; }
+            public DateOnly? DateOnlyNullable { get; set; }
+        }
+    }
+}