Merge pull request #40 from evolvedlight/add-default-mappings

StevenRasmussen · web-flow · commit f205e4316926 · 2024-04-06T10:31:16.000-06:00
Add default mappings for types. Change visibility to public for mappings to allow compiled ef contexts
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Tests/MappingDefaultsTest.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Tests/MappingDefaultsTest.cs
@@ -0,0 +1,77 @@
+﻿using Microsoft.EntityFrameworkCore.SqlServer.Storage;
+using NodaTime;
+using System;
+using Xunit;
+
+namespace SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Tests
+{
+    public class MappingDefaultsTest
+    {
+        [Fact]
+        public void Duration_Defaults()
+        {
+            var durationDefault = DurationTypeMapping.Default;
+
+            Assert.NotNull(durationDefault);
+
+            Assert.Equal("time", durationDefault.StoreType);
+            Assert.Equal("'02:30:01'", durationDefault.GenerateSqlLiteral(Duration.FromTimeSpan(new TimeSpan(2, 30, 1))));
+        }
+
+        [Fact]
+        public void Instant_Defaults()
+        {
+            var instantDefault = InstantTypeMapping.Default;
+
+            Assert.NotNull(instantDefault);
+
+            Assert.Equal("datetime2", instantDefault.StoreType);
+            Assert.Equal("'2024-02-14T00:14:00.0000000Z'", instantDefault.GenerateSqlLiteral(Instant.FromUtc(2024, 02, 14, 0, 14)));
+        }
+
+        [Fact]
+        public void LocalDateTime_Defaults()
+        {
+            var localDateTimeDefault = LocalDateTimeTypeMapping.Default;
+
+            Assert.NotNull(localDateTimeDefault);
+
+            Assert.Equal("datetime2", localDateTimeDefault.StoreType);
+            Assert.Equal("'2024-04-01T13:15:00.0000000'", localDateTimeDefault.GenerateSqlLiteral(new LocalDateTime(2024, 04, 01, 13, 15)));
+        }
+
+        [Fact]
+        public void LocalDate_Defaults()
+        {
+            var localDateDefault = LocalDateTypeMapping.Default;
+
+            Assert.NotNull(localDateDefault);
+
+            Assert.Equal("date", localDateDefault.StoreType);
+            Assert.Equal("'2024-03-30'", localDateDefault.GenerateSqlLiteral(new LocalDate(2024, 03, 30)));
+        }
+
+        [Fact]
+        public void LocalTime_Defaults()
+        {
+            var localTimeDefault = LocalTimeTypeMapping.Default;
+
+            Assert.NotNull(localTimeDefault);
+
+            Assert.Equal("time", localTimeDefault.StoreType);
+            Assert.Equal("'19:40:00'", localTimeDefault.GenerateSqlLiteral(new LocalTime(19, 40)));
+        }
+
+        [Fact]
+        public void OffsetDateTime_Defaults()
+        {
+            var offsetDateTimeDefault = OffsetDateTimeTypeMapping.Default;
+
+            Assert.NotNull(offsetDateTimeDefault);
+
+            Assert.Equal("datetimeoffset", offsetDateTimeDefault.StoreType);
+            var localDateTime = new LocalDateTime(2024, 04, 01, 17, 15);
+            Assert.Equal("'2024-04-01T17:15:00.0000000+02:00'", offsetDateTimeDefault.GenerateSqlLiteral(new OffsetDateTime(localDateTime, Offset.FromHours(2))));
+        }
+    }
+}
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/DurationTypeMapping.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/DurationTypeMapping.cs
@@ -7,8 +7,16 @@
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage
 {
-    internal class DurationTypeMapping : RelationalTypeMapping
+    public class DurationTypeMapping : RelationalTypeMapping
     {
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public static DurationTypeMapping Default { get; } = new();
+
         public DurationTypeMapping()
             : base(CreateRelationalTypeMappingParameters())
         {
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/DurationValueConverter.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/DurationValueConverter.cs
@@ -11,12 +11,12 @@ public DurationValueConverter()
         {
         }
 
-        private static TimeSpan toProvider(Duration duration)
+        public static TimeSpan toProvider(Duration duration)
         {
             return duration.ToTimeSpan();
         }
 
-        private static Duration fromProvider(TimeSpan timeSpan)
+        public static Duration fromProvider(TimeSpan timeSpan)
         {
             return Duration.FromTimeSpan(timeSpan);
         }
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/InstantTypeMapping.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/InstantTypeMapping.cs
@@ -1,11 +1,20 @@
 ﻿using Microsoft.EntityFrameworkCore.Storage;
 using NodaTime;
+using SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Storage;
 using DateTimeTypeMapping = SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Storage.DateTimeTypeMapping;
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage
 {
-    internal class InstantTypeMapping : DateTimeTypeMapping
+    public class InstantTypeMapping : DateTimeTypeMapping
     {
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public static InstantTypeMapping Default { get; } = new(SqlServerDateTimeTypes.DateTime2);
+
         public InstantTypeMapping(string storeType)
             : base(storeType, typeof(Instant), new InstantValueConverter())
         {
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/InstantValueConverter.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/InstantValueConverter.cs
@@ -11,12 +11,12 @@ public InstantValueConverter()
         {
         }
 
-        private static DateTime toProvider(Instant instant)
+        public static DateTime toProvider(Instant instant)
         {
             return instant.ToDateTimeUtc();
         }
 
-        private static Instant fromProvider(DateTime dateTime)
+        public static Instant fromProvider(DateTime dateTime)
         {
             return Instant.FromDateTimeUtc(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc));
         }
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateTimeTypeMapping.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateTimeTypeMapping.cs
@@ -1,11 +1,20 @@
 ﻿using Microsoft.EntityFrameworkCore.Storage;
 using NodaTime;
+using SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Storage;
 using DateTimeTypeMapping = SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime.Storage.DateTimeTypeMapping;
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage
 {
-    internal class LocalDateTimeTypeMapping : DateTimeTypeMapping
+    public class LocalDateTimeTypeMapping : DateTimeTypeMapping
     {
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public static LocalDateTimeTypeMapping Default { get; } = new(SqlServerDateTimeTypes.DateTime2);
+
         public LocalDateTimeTypeMapping(string storeType)
             : base(storeType, typeof(LocalDateTime), new LocalDateTimeValueConverter())
         {
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateTimeValueConverter.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateTimeValueConverter.cs
@@ -11,12 +11,12 @@ public LocalDateTimeValueConverter()
         {
         }
 
-        private static DateTime toProvider(LocalDateTime localDateTime)
+        public static DateTime toProvider(LocalDateTime localDateTime)
         {
             return localDateTime.ToDateTimeUnspecified();
         }
 
-        private static LocalDateTime fromProvider(DateTime dateTime)
+        public static LocalDateTime fromProvider(DateTime dateTime)
         {
             return LocalDateTime.FromDateTime(dateTime);
         }
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateTypeMapping.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateTypeMapping.cs
@@ -8,10 +8,18 @@
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage
 {
-    internal class LocalDateTypeMapping : RelationalTypeMapping
+    public class LocalDateTypeMapping : RelationalTypeMapping
     {
         private const string DateFormatConst = "'{0:yyyy-MM-dd}'";
 
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public static LocalDateTypeMapping Default { get; } = new();
+
         public LocalDateTypeMapping()
             : base(CreateRelationalTypeMappingParameters())
         {
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateValueConverter.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalDateValueConverter.cs
@@ -11,12 +11,12 @@ public LocalDateValueConverter()
         {
         }
 
-        private static DateTime toProvider(LocalDate localDate)
+        public static DateTime toProvider(LocalDate localDate)
         {
             return localDate.ToDateTimeUnspecified();
         }
 
-        private static LocalDate fromProvider(DateTime dateTime)
+        public static LocalDate fromProvider(DateTime dateTime)
         {
             return LocalDate.FromDateTime(dateTime);
         }
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalTimeTypeMapping.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalTimeTypeMapping.cs
@@ -7,8 +7,16 @@
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage
 {
-    internal class LocalTimeTypeMapping : RelationalTypeMapping
+    public class LocalTimeTypeMapping : RelationalTypeMapping
     {
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public static LocalTimeTypeMapping Default { get; } = new();
+
         public LocalTimeTypeMapping()
             : base(CreateRelationalTypeMappingParameters())
         {
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalTimeValueConverter.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/LocalTimeValueConverter.cs
@@ -11,12 +11,12 @@ public LocalTimeValueConverter()
         {
         }
 
-        private static TimeSpan toProvider(LocalTime localTime)
+        public static TimeSpan toProvider(LocalTime localTime)
         {
             return new TimeSpan(localTime.TickOfDay);
         }
 
-        private static LocalTime fromProvider(TimeSpan dateTime)
+        public static LocalTime fromProvider(TimeSpan dateTime)
         {
             return LocalTime.FromTicksSinceMidnight(dateTime.Ticks);
         }
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/OffsetDateTimeTypeMapping.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/OffsetDateTimeTypeMapping.cs
@@ -5,10 +5,18 @@
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage
 {
-    internal class OffsetDateTimeTypeMapping : RelationalTypeMapping
+    public class OffsetDateTimeTypeMapping : RelationalTypeMapping
     {
         private const string DateTimeOffsetFormatConst = "{0:yyyy-MM-ddTHH:mm:ss.fffffffzzz}";
 
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public static OffsetDateTimeTypeMapping Default { get; } = new();
+
         public OffsetDateTimeTypeMapping()
             : base(CreateRelationalTypeMappingParameters())
         {
diff --git a/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/OffsetDateTimeValueConverter.cs b/src/SimplerSoftware.EntityFrameworkCore.SqlServer.NodaTime/Storage/OffsetDateTimeValueConverter.cs
@@ -11,12 +11,12 @@ public OffsetDateTimeValueConverter()
         {
         }
 
-        private static DateTimeOffset toProvider(OffsetDateTime offsetDateTime)
+        public static DateTimeOffset toProvider(OffsetDateTime offsetDateTime)
         {
             return offsetDateTime.ToDateTimeOffset();
         }
 
-        private static OffsetDateTime fromProvider(DateTimeOffset dateTimeOffset)
+        public static OffsetDateTime fromProvider(DateTimeOffset dateTimeOffset)
         {
             return OffsetDateTime.FromDateTimeOffset(dateTimeOffset);
         }

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,16 @@`
`7`	`7`
`8`	`8`	`namespace Microsoft.EntityFrameworkCore.SqlServer.Storage`
`9`	`9`	`{`
`10`		`- internal class DurationTypeMapping : RelationalTypeMapping`
	`10`	`+ public class DurationTypeMapping : RelationalTypeMapping`
`11`	`11`	`{`
	`12`	`+ /// <summary>`
	`13`	`+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to`
	`14`	`+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in`
	`15`	`+ /// any release. You should only use it directly in your code with extreme caution and knowing that`
	`16`	`+ /// doing so can result in application failures when updating to a new Entity Framework Core release.`
	`17`	`+ /// </summary>`
	`18`	`+ public static DurationTypeMapping Default { get; } = new();`
	`19`	`+`
`12`	`20`	`public DurationTypeMapping()`
`13`	`21`	`: base(CreateRelationalTypeMappingParameters())`
`14`	`22`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ public DurationValueConverter()`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`		`- private static TimeSpan toProvider(Duration duration)`
	`14`	`+ public static TimeSpan toProvider(Duration duration)`
`15`	`15`	`{`
`16`	`16`	`return duration.ToTimeSpan();`
`17`	`17`	`}`
`18`	`18`
`19`		`- private static Duration fromProvider(TimeSpan timeSpan)`
	`19`	`+ public static Duration fromProvider(TimeSpan timeSpan)`
`20`	`20`	`{`
`21`	`21`	`return Duration.FromTimeSpan(timeSpan);`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ public InstantValueConverter()`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`		`- private static DateTime toProvider(Instant instant)`
	`14`	`+ public static DateTime toProvider(Instant instant)`
`15`	`15`	`{`
`16`	`16`	`return instant.ToDateTimeUtc();`
`17`	`17`	`}`
`18`	`18`
`19`		`- private static Instant fromProvider(DateTime dateTime)`
	`19`	`+ public static Instant fromProvider(DateTime dateTime)`
`20`	`20`	`{`
`21`	`21`	`return Instant.FromDateTimeUtc(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc));`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ public LocalDateTimeValueConverter()`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`		`- private static DateTime toProvider(LocalDateTime localDateTime)`
	`14`	`+ public static DateTime toProvider(LocalDateTime localDateTime)`
`15`	`15`	`{`
`16`	`16`	`return localDateTime.ToDateTimeUnspecified();`
`17`	`17`	`}`
`18`	`18`
`19`		`- private static LocalDateTime fromProvider(DateTime dateTime)`
	`19`	`+ public static LocalDateTime fromProvider(DateTime dateTime)`
`20`	`20`	`{`
`21`	`21`	`return LocalDateTime.FromDateTime(dateTime);`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,18 @@`
`8`	`8`
`9`	`9`	`namespace Microsoft.EntityFrameworkCore.SqlServer.Storage`
`10`	`10`	`{`
`11`		`- internal class LocalDateTypeMapping : RelationalTypeMapping`
	`11`	`+ public class LocalDateTypeMapping : RelationalTypeMapping`
`12`	`12`	`{`
`13`	`13`	`private const string DateFormatConst = "'{0:yyyy-MM-dd}'";`
`14`	`14`
	`15`	`+ /// <summary>`
	`16`	`+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to`
	`17`	`+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in`
	`18`	`+ /// any release. You should only use it directly in your code with extreme caution and knowing that`
	`19`	`+ /// doing so can result in application failures when updating to a new Entity Framework Core release.`
	`20`	`+ /// </summary>`
	`21`	`+ public static LocalDateTypeMapping Default { get; } = new();`
	`22`	`+`
`15`	`23`	`public LocalDateTypeMapping()`
`16`	`24`	`: base(CreateRelationalTypeMappingParameters())`
`17`	`25`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ public LocalDateValueConverter()`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`		`- private static DateTime toProvider(LocalDate localDate)`
	`14`	`+ public static DateTime toProvider(LocalDate localDate)`
`15`	`15`	`{`
`16`	`16`	`return localDate.ToDateTimeUnspecified();`
`17`	`17`	`}`
`18`	`18`
`19`		`- private static LocalDate fromProvider(DateTime dateTime)`
	`19`	`+ public static LocalDate fromProvider(DateTime dateTime)`
`20`	`20`	`{`
`21`	`21`	`return LocalDate.FromDateTime(dateTime);`
`22`	`22`	`}`