Fix DateTime fractions logic and make milliseconds support opt-in (#86)

* Ensure deterministic test ordering.

* Fix DateTime factions logic.

* Make milliseconds support opt-in.

* Fix logic and add tests.

* Fix DateTime related OLE DB parameter configuration.

Author: lauxjpn

src/EFCore.Jet.Data/JetDataReader.cs

@@ -148,12 +148,25 @@ public override DateTime GetDateTime(int ordinal)
             // Since DATETIME values are really just DOUBLE values internally in Jet, we explicitly convert those vales
             // to DOUBLE in the most outer SELECT projections as a workaround.
             var value = _wrappedDataReader.GetValue(ordinal);
-            return JetConfiguration.UseDefaultValueOnDBNullConversionError &&
-                   Convert.IsDBNull(value)
-                ? default
-                : value is double doubleValue
-                    ? new DateTime(JetConfiguration.TimeSpanOffset.Ticks + (long) (doubleValue * TimeSpan.TicksPerDay))
-                    : (DateTime) value;
+            
+            if (JetConfiguration.UseDefaultValueOnDBNullConversionError &&
+                Convert.IsDBNull(value))
+                return default;
+
+            if (value is double doubleValue)
+            {
+                // Round to milliseconds.
+                return new DateTime(
+                    JetConfiguration.TimeSpanOffset.Ticks +
+                    (long) (Math.Round(
+                                (decimal) (long) ((decimal) doubleValue * TimeSpan.TicksPerDay) /
+                                TimeSpan.TicksPerMillisecond,
+                                0,
+                                MidpointRounding.AwayFromZero) *
+                            TimeSpan.TicksPerMillisecond));
+            }
+
+            return (DateTime) value;
         }
 
         public virtual TimeSpan GetTimeSpan(int ordinal)

src/EFCore.Jet/Infrastructure/Internal/IJetOptions.cs

@@ -14,5 +14,6 @@ public interface IJetOptions : ISingletonOptions
         string ConnectionString { get; }
         DataAccessProviderType DataAccessProviderType { get; }
         bool UseOuterSelectSkipEmulationViaDataReader { get; }
+        bool EnableMillisecondsSupport { get; }
     }
 }

src/EFCore.Jet/Infrastructure/Internal/JetOptionsExtension.cs

@@ -23,6 +23,7 @@ public class JetOptionsExtension : RelationalOptionsExtension
         // private bool? _rowNumberPaging;
         private DbProviderFactory _dataAccessProviderFactory;
         private bool _useOuterSelectSkipEmulationViaDataReader;
+        private bool _enableMillisecondsSupport;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -48,6 +49,7 @@ protected JetOptionsExtension([NotNull] JetOptionsExtension copyFrom)
             // _rowNumberPaging = copyFrom._rowNumberPaging;
             _dataAccessProviderFactory = copyFrom._dataAccessProviderFactory;
             _useOuterSelectSkipEmulationViaDataReader = copyFrom._useOuterSelectSkipEmulationViaDataReader;
+            _enableMillisecondsSupport = copyFrom._enableMillisecondsSupport;
         }
 
         /// <summary>
@@ -139,6 +141,29 @@ public virtual JetOptionsExtension WithUseOuterSelectSkipEmulationViaDataReader(
             return clone;
         }
 
+        /// <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 virtual bool EnableMillisecondsSupport => _enableMillisecondsSupport;
+
+        /// <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 virtual JetOptionsExtension WithEnableMillisecondsSupport(bool enabled)
+        {
+            var clone = (JetOptionsExtension) Clone();
+
+            clone._enableMillisecondsSupport = enabled;
+
+            return clone;
+        }
+
         /// <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
@@ -190,6 +215,11 @@ public override string LogFragment
                             builder.Append("UseOuterSelectSkipEmulationViaDataReader ");
                         }
 
+                        if (Extension._enableMillisecondsSupport)
+                        {
+                            builder.Append("EnableMillisecondsSupport ");
+                        }
+
                         _logFragment = builder.ToString();
                     }
 
@@ -203,7 +233,8 @@ public override long GetServiceProviderHashCode()
                 {
                     _serviceProviderHash = (base.GetServiceProviderHashCode() * 397) ^
                                            (Extension._dataAccessProviderFactory?.GetHashCode() ?? 0L) ^
-                                           (Extension._useOuterSelectSkipEmulationViaDataReader.GetHashCode() * 397) /* ^
+                                           (Extension._useOuterSelectSkipEmulationViaDataReader.GetHashCode() * 397) ^
+                                           (Extension._enableMillisecondsSupport.GetHashCode() * 397)/* ^
                                            (Extension._rowNumberPaging?.GetHashCode() ?? 0L)*/;
                 }
 
@@ -222,6 +253,8 @@ public override void PopulateDebugInfo(IDictionary<string, string> debugInfo)
                 debugInfo["Jet:" + nameof(JetDbContextOptionsBuilder.UseOuterSelectSkipEmulationViaDataReader)]
 #pragma warning restore 618
                     = Extension._useOuterSelectSkipEmulationViaDataReader.GetHashCode().ToString(CultureInfo.InvariantCulture);
+                debugInfo["Jet:" + nameof(JetDbContextOptionsBuilder.EnableMillisecondsSupport)]
+                    = Extension._enableMillisecondsSupport.GetHashCode().ToString(CultureInfo.InvariantCulture);
             }
         }
     }

src/EFCore.Jet/Infrastructure/JetDbContextOptionsBuilder.cs

@@ -47,6 +47,13 @@ public JetDbContextOptionsBuilder([NotNull] DbContextOptionsBuilder optionsBuild
         public virtual JetDbContextOptionsBuilder UseOuterSelectSkipEmulationViaDataReader(bool enabled = true)
             => WithOption(e => e.WithUseOuterSelectSkipEmulationViaDataReader(enabled));
 
+        /// <summary>
+        ///     Configures the context support milliseconds in `DateTime`, `DateTimeOffset` and `TimeSpan` values when
+        ///     accessing Jet databases. Jet has no native support for milliseconds, therefore this feature is opt-in.
+        /// </summary>
+        public virtual JetDbContextOptionsBuilder EnableMillisecondsSupport(bool enabled = true)
+            => WithOption(e => e.WithEnableMillisecondsSupport(enabled));
+
         /// <summary>
         ///     Configures the context to use the default retrying <see cref="IExecutionStrategy" />.
         /// </summary>

src/EFCore.Jet/Internal/JetOptions.cs

@@ -28,6 +28,7 @@ public virtual void Initialize(IDbContextOptions options)
 
             DataAccessProviderType = GetDataAccessProviderTypeFromOptions(jetOptions);
             UseOuterSelectSkipEmulationViaDataReader = jetOptions.UseOuterSelectSkipEmulationViaDataReader;
+            EnableMillisecondsSupport = jetOptions.EnableMillisecondsSupport;
             ConnectionString = jetOptions.Connection?.ConnectionString ?? jetOptions.ConnectionString;
         }
 
@@ -64,6 +65,14 @@ public virtual void Validate(IDbContextOptions options)
                         nameof(JetOptionsExtension.UseOuterSelectSkipEmulationViaDataReader),
                         nameof(DbContextOptionsBuilder.UseInternalServiceProvider)));
             }
+
+            if (EnableMillisecondsSupport != jetOptions.EnableMillisecondsSupport)
+            {
+                throw new InvalidOperationException(
+                    CoreStrings.SingletonOptionChanged(
+                        nameof(JetOptionsExtension.EnableMillisecondsSupport),
+                        nameof(DbContextOptionsBuilder.UseInternalServiceProvider)));
+            }
         }
 
         private static DataAccessProviderType GetDataAccessProviderTypeFromOptions(JetOptionsExtension jetOptions)
@@ -125,6 +134,14 @@ private static DataAccessProviderType GetDataAccessProviderTypeFromOptions(JetOp
         /// </summary>
         public virtual bool UseOuterSelectSkipEmulationViaDataReader { get; private set; }
 
+        /// <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 bool EnableMillisecondsSupport { get; private set; }
+
         /// <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

src/EFCore.Jet/Migrations/JetMigrationsSqlGenerator.cs

@@ -773,7 +773,7 @@ protected override void DefaultValue(
                 }
 
                 defaultValue = defaultValue.GetType().IsTimeRelatedType()
-                    ? JetDateTimeTypeMapping.GenerateNonNullSqlLiteral(defaultValue, true)
+                    ? JetDateTimeTypeMapping.GenerateNonNullSqlLiteral(defaultValue, true, _options.EnableMillisecondsSupport)
                     : typeMapping.GenerateSqlLiteral(defaultValue);
 
                 builder

src/EFCore.Jet/Query/Internal/JetQueryTranslationPostprocessor.cs

@@ -1,26 +1,35 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.Linq.Expressions;
+using EntityFrameworkCore.Jet.Infrastructure.Internal;
 using Microsoft.EntityFrameworkCore.Query;
 
 namespace EntityFrameworkCore.Jet.Query.Internal
 {
     public class JetQueryTranslationPostprocessor : RelationalQueryTranslationPostprocessor
     {
+        private readonly IJetOptions _options;
+
         public JetQueryTranslationPostprocessor(
             QueryTranslationPostprocessorDependencies dependencies,
             RelationalQueryTranslationPostprocessorDependencies relationalDependencies,
-            QueryCompilationContext queryCompilationContext)
+            QueryCompilationContext queryCompilationContext,
+            IJetOptions options)
             : base(dependencies, relationalDependencies, queryCompilationContext)
         {
+            _options = options;
         }
 
         public override Expression Process(Expression query)
         {
             query = base.Process(query);
 
             query = new SearchConditionConvertingExpressionVisitor(SqlExpressionFactory).Visit(query);
-            query = new JetDateTimeExpressionVisitor(SqlExpressionFactory).Visit(query);
+
+            if (_options.EnableMillisecondsSupport)
+            {
+                query = new JetDateTimeExpressionVisitor(SqlExpressionFactory).Visit(query);
+            }
 
             return query;
         }

src/EFCore.Jet/Query/Internal/JetQueryTranslationPostprocessorFactory.cs

@@ -1,5 +1,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using EntityFrameworkCore.Jet.Infrastructure.Internal;
 using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -22,19 +23,23 @@ public class JetQueryTranslationPostprocessorFactory : IQueryTranslationPostproc
     {
         private readonly QueryTranslationPostprocessorDependencies _dependencies;
         private readonly RelationalQueryTranslationPostprocessorDependencies _relationalDependencies;
+        private readonly IJetOptions _options;
 
         public JetQueryTranslationPostprocessorFactory(
             QueryTranslationPostprocessorDependencies dependencies,
-            RelationalQueryTranslationPostprocessorDependencies relationalDependencies)
+            RelationalQueryTranslationPostprocessorDependencies relationalDependencies,
+            IJetOptions options)
         {
             _dependencies = dependencies;
             _relationalDependencies = relationalDependencies;
+            _options = options;
         }
 
         public virtual QueryTranslationPostprocessor Create(QueryCompilationContext queryCompilationContext)
             => new JetQueryTranslationPostprocessor(
                 _dependencies,
                 _relationalDependencies,
-                queryCompilationContext);
+                queryCompilationContext,
+                _options);
     }
 }

src/EFCore.Jet/Storage/Internal/JetDateTimeOffsetTypeMapping.cs

@@ -2,31 +2,37 @@
 
 using System;
 using System.Data.Common;
+using EntityFrameworkCore.Jet.Infrastructure.Internal;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Storage;
 
 namespace EntityFrameworkCore.Jet.Storage.Internal
 {
     public class JetDateTimeOffsetTypeMapping : JetDateTimeTypeMapping
     {
+        private readonly IJetOptions _options;
+
         public JetDateTimeOffsetTypeMapping(
-                [NotNull] string storeType)
+                [NotNull] string storeType,
+                [NotNull] IJetOptions options)
             : base(
                 storeType,
+                options,
                 System.Data.DbType.DateTime,
                 typeof(DateTimeOffset)) // delibrately use DbType.DateTime, because OleDb will throw a
                                         // "No mapping exists from DbType DateTimeOffset to a known OleDbType."
                                         // exception when using DbType.DateTimeOffset.
         {
+            _options = options;
         }
 
-        protected JetDateTimeOffsetTypeMapping(RelationalTypeMappingParameters parameters)
-            : base(parameters)
+        protected JetDateTimeOffsetTypeMapping(RelationalTypeMappingParameters parameters, IJetOptions options)
+            : base(parameters, options)
         {
         }
 
         protected override RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters)
-            => new JetDateTimeOffsetTypeMapping(parameters);
+            => new JetDateTimeOffsetTypeMapping(parameters, _options);
 
         protected override void ConfigureParameter(DbParameter parameter)
         {