CSHARP-4540: Add full support for $dateFromString.

rstam · rstam · commit ffcf4a0a5f15 · 2024-01-30T10:39:40.000-08:00
diff --git a/src/MongoDB.Driver.Core/Core/Misc/Feature.cs b/src/MongoDB.Driver.Core/Core/Misc/Feature.cs
@@ -66,6 +66,7 @@ public class Feature
         private static readonly Feature __csfle2 = new Feature("Csfle2", WireVersion.Server60);
         private static readonly Feature __csfle2Qev2 = new Feature("Csfle2Qev2", WireVersion.Server70, notSupportedMessage: "Driver support of Queryable Encryption is incompatible with server. Upgrade server to use Queryable Encryption.");
         private static readonly Feature __currentOpCommand = new Feature("CurrentOpCommand", WireVersion.Server32);
+        private static readonly Feature __dateFromStringFormatArgument = new Feature("DateFromStringFormatArgument", WireVersion.Server40);
         private static readonly Feature __dateOperatorsNewIn50 = new Feature("DateOperatorsNewIn50", WireVersion.Server50);
         private static readonly Feature __densifyStage = new Feature("DensifyStage", WireVersion.Server51);
         private static readonly Feature __documentsStage = new Feature("DocumentsStage", WireVersion.Server51);
@@ -375,6 +376,11 @@ public class Feature
         [Obsolete("This property will be removed in a later release.")]
         public static Feature CurrentOpCommand => __currentOpCommand;
 
+        /// <summary>
+        /// Gets the $dateFromString format argument feature.
+        /// </summary>
+        public static Feature DateFromStringFormatArgument => __dateFromStringFormatArgument;
+
         /// <summary>
         /// Gets the date operators added in 5.0 feature.
         /// </summary>
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/MqlMethod.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/MqlMethod.cs
@@ -13,26 +13,39 @@
 * limitations under the License.
 */
 
+using System;
 using System.Reflection;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Reflection
 {
     internal static class MqlMethod
     {
         // private static fields
+        private static readonly MethodInfo __dateFromString;
+        private static readonly MethodInfo __dateFromStringWithFormat;
+        private static readonly MethodInfo __dateFromStringWithFormatAndTimezone;
+        private static readonly MethodInfo __dateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull;
         private static readonly MethodInfo __exists;
         private static readonly MethodInfo __isMissing;
         private static readonly MethodInfo __isNullOrMissing;
 
         // static constructor
         static MqlMethod()
         {
+            __dateFromString = ReflectionInfo.Method((string dateStringl) => Mql.DateFromString(dateStringl));
+            __dateFromStringWithFormat = ReflectionInfo.Method((string dateString, string format) => Mql.DateFromString(dateString, format));
+            __dateFromStringWithFormatAndTimezone = ReflectionInfo.Method((string dateString, string format, string timezone) => Mql.DateFromString(dateString, format, timezone));
+            __dateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull = ReflectionInfo.Method((string dateString, string format, string timezone, DateTime? onError, DateTime? onNull) => Mql.DateFromString(dateString, format, timezone, onError, onNull));
             __exists = ReflectionInfo.Method((object field) => Mql.Exists(field));
             __isMissing = ReflectionInfo.Method((object field) => Mql.IsMissing(field));
             __isNullOrMissing = ReflectionInfo.Method((object field) => Mql.IsNullOrMissing(field));
         }
 
         // public properties
+        public static MethodInfo DateFromString => __dateFromString;
+        public static MethodInfo DateFromStringWithFormat => __dateFromStringWithFormat;
+        public static MethodInfo DateFromStringWithFormatAndTimezone => __dateFromStringWithFormatAndTimezone;
+        public static MethodInfo DateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull => __dateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull;
         public static MethodInfo Exists => __exists;
         public static MethodInfo IsMissing => __isMissing;
         public static MethodInfo IsNullOrMissing => __isNullOrMissing;
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodCallExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodCallExpressionToAggregationExpressionTranslator.cs
@@ -40,6 +40,7 @@ public static AggregationExpression Translate(TranslationContext context, Method
                 case "CovariancePopulation": return CovariancePopulationMethodToAggregationExpressionTranslator.Translate(context, expression);
                 case "CovarianceSample": return CovarianceSampleMethodToAggregationExpressionTranslator.Translate(context, expression);
                 case "Create": return CreateMethodToAggregationExpressionTranslator.Translate(context, expression);
+                case "DateFromString": return DateFromStringMethodToAggregationExpressionTranslator.Translate(context, expression);
                 case "DefaultIfEmpty": return DefaultIfEmptyMethodToAggregationExpressionTranslator.Translate(context, expression);
                 case "DenseRank": return DenseRankMethodToAggregationExpressionTranslator.Translate(context, expression);
                 case "Derivative": return DerivativeMethodToAggregationExpressionTranslator.Translate(context, expression);
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/DateFromStringMethodToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/DateFromStringMethodToAggregationExpressionTranslator.cs
@@ -0,0 +1,99 @@
+﻿/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System.Linq.Expressions;
+using System.Reflection;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToAggregationExpressionTranslators.MethodTranslators
+{
+    internal static class DateFromStringMethodToAggregationExpressionTranslator
+    {
+        private static readonly MethodInfo[] __dateFromStringMethods =
+        {
+            MqlMethod.DateFromString,
+            MqlMethod.DateFromStringWithFormat,
+            MqlMethod.DateFromStringWithFormatAndTimezone,
+            MqlMethod.DateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull
+        };
+
+        private static readonly MethodInfo[] __withFormatMethods =
+        {
+            MqlMethod.DateFromStringWithFormat,
+            MqlMethod.DateFromStringWithFormatAndTimezone,
+            MqlMethod.DateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull
+        };
+
+        private static readonly MethodInfo[] __withTimezoneMethods =
+        {
+            MqlMethod.DateFromStringWithFormatAndTimezone,
+            MqlMethod.DateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull
+        };
+
+        public static AggregationExpression Translate(TranslationContext context, MethodCallExpression expression)
+        {
+            var method = expression.Method;
+            var arguments = expression.Arguments;
+
+            if (method.IsOneOf(__dateFromStringMethods))
+            {
+                var dateStringExpression = arguments[0];
+                var dateStringTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, dateStringExpression);
+                var dateStringAst = dateStringTranslation.Ast;
+                IBsonSerializer resultSerializer = DateTimeSerializer.Instance;
+
+                AstExpression format = null;
+                if (method.IsOneOf(__withFormatMethods))
+                {
+                    var formatExpression = arguments[1];
+                    var formatTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, formatExpression);
+                    format = formatTranslation.Ast;
+                }
+
+                AstExpression timezoneAst = null;
+                if (method.IsOneOf(__withTimezoneMethods))
+                {
+                    var timezoneExpression = arguments[2];
+                    var timezoneTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, timezoneExpression);
+                    timezoneAst = timezoneTranslation.Ast;
+                }
+
+                AstExpression onErrorAst = null;
+                AstExpression onNullAst = null;
+                if (method.Is(MqlMethod.DateFromStringWithFormatAndTimezoneAndOnErrorAndOnNull))
+                {
+                    var onErrorExpression = arguments[3];
+                    var onErrorTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, onErrorExpression);
+                    onErrorAst = onErrorTranslation.Ast;
+
+                    var onNullExpression = arguments[4];
+                    var onNullTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, onNullExpression);
+                    onNullAst = onNullTranslation.Ast;
+
+                    resultSerializer = NullableSerializer.Create(resultSerializer);
+                }
+
+                var ast = AstExpression.DateFromString(dateStringAst, format, timezoneAst, onErrorAst, onNullAst);
+                return new AggregationExpression(expression, ast, resultSerializer);
+            }
+
+            throw new ExpressionNotSupportedException(expression);
+        }
+    }
+}
diff --git a/src/MongoDB.Driver/Mql.cs b/src/MongoDB.Driver/Mql.cs
@@ -22,6 +22,63 @@ namespace MongoDB.Driver
     /// </summary>
     public static class Mql
     {
+        /// <summary>
+        /// Converts a string to a DateTime using the $dateFromString aggregation operator.
+        /// </summary>
+        /// <param name="dateString">The string.</param>
+        /// <returns>A DateTime.</returns>
+        public static DateTime DateFromString(string dateString)
+        {
+            throw new NotSupportedException("This method is not functional. It is only usable in MongoDB LINQ queries.");
+        }
+
+        /// <summary>
+        /// Converts a string to a DateTime using the $dateFromString aggregation operator.
+        /// </summary>
+        /// <param name="dateString">The string.</param>
+        /// <param name="format">The format string.</param>
+        /// <returns>A DateTime.</returns>
+        public static DateTime DateFromString(
+            string dateString,
+            string format)
+        {
+            throw new NotSupportedException("This method is not functional. It is only usable in MongoDB LINQ queries.");
+        }
+
+        /// <summary>
+        /// Converts a string to a DateTime using the $dateFromString aggregation operator.
+        /// </summary>
+        /// <param name="dateString">The string.</param>
+        /// <param name="format">The format string.</param>
+        /// <param name="timezone">The time zone.</param>
+        /// <returns>A DateTime.</returns>
+        public static DateTime DateFromString(
+            string dateString,
+            string format,
+            string timezone)
+        {
+            throw new NotSupportedException("This method is not functional. It is only usable in MongoDB LINQ queries.");
+        }
+
+        /// <summary>
+        /// Converts a string to a DateTime using the $dateFromString aggregation operator.
+        /// </summary>
+        /// <param name="dateString">The string.</param>
+        /// <param name="format">The format string.</param>
+        /// <param name="timezone">The time zone.</param>
+        /// <param name="onError">The onError value.</param>
+        /// <param name="onNull">The onNull value.</param>
+        /// <returns>A DateTime.</returns>
+        public static DateTime? DateFromString(
+            string dateString,
+            string format,
+            string timezone,
+            DateTime? onError,
+            DateTime? onNull)
+        {
+            throw new NotSupportedException("This method is not functional. It is only usable in MongoDB LINQ queries.");
+        }
+
         /// <summary>
         /// Tests whether a field exists.
         /// </summary>
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/DateFromStringMethodToAggregationExpressionTranslatorTests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/DateFromStringMethodToAggregationExpressionTranslatorTests.cs
