CSHARP-4066: Only use regex filters against string properties that are serialized as strings.

Author: rstam

src/MongoDB.Driver/Linq/ExpressionNotSupportedException.cs

@@ -29,10 +29,20 @@ private static string FormatMessage(Expression expression)
             return $"Expression not supported: {expression}.";
         }
 
+        private static string FormatMessage(Expression expression, string because)
+        {
+            return $"Expression not supported: {expression} because {because}.";
+        }
+
         private static string FormatMessage(Expression expression, Expression containingExpression)
         {
             return $"Expression not supported: {expression} in {containingExpression}.";
         }
+
+        private static string FormatMessage(Expression expression, Expression containingExpression, string because)
+        {
+            return $"Expression not supported: {expression} in {containingExpression} because {because}.";
+        }
         #endregion
 
         // constructors
@@ -54,6 +64,16 @@ public ExpressionNotSupportedException(Expression expression)
         {
         }
 
+        /// <summary>
+        /// Initializes an instance of an ExpressionNotSupportedException.
+        /// </summary>
+        /// <param name="expression">The expression.</param>
+        /// <param name="because">The reason.</param>
+        public ExpressionNotSupportedException(Expression expression, string because)
+            : base(FormatMessage(expression, because))
+        {
+        }
+
         /// <summary>
         /// Initializes an instance of an ExpressionNotSupportedException.
         /// </summary>
@@ -63,5 +83,16 @@ public ExpressionNotSupportedException(Expression expression, Expression contain
             : base(FormatMessage(expression, containingExpression))
         {
         }
+
+        /// <summary>
+        /// Initializes an instance of an ExpressionNotSupportedException.
+        /// </summary>
+        /// <param name="expression">The expression.</param>
+        /// <param name="containingExpression">The containing expression.</param>
+        /// <param name="because">The reason.</param>
+        public ExpressionNotSupportedException(Expression expression, Expression containingExpression, string because)
+            : base(FormatMessage(expression, containingExpression, because))
+        {
+        }
     }
 }

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Filters/AstFieldOperationFilter.cs

@@ -13,7 +13,9 @@
 * limitations under the License.
 */
 
+using System;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Visitors;
 
@@ -28,6 +30,14 @@ public AstFieldOperationFilter(AstFilterField field, AstFilterOperation operatio
         {
             _field = Ensure.IsNotNull(field, nameof(field));
             _operation = Ensure.IsNotNull(operation, nameof(operation));
+
+            if (operation.NodeType == AstNodeType.RegexFilterOperation &&
+                field.Serializer is IRepresentationConfigurable representationConfigurable &&
+                representationConfigurable.Representation != BsonType.String)
+            {
+                // normally an ExpressionNotSupported should have been thrown before reaching here
+                throw new ArgumentException($"Field must be represented as a string for regex filter operations: {field.Path}", nameof(field));
+            }
         }
 
         public new AstFilterField Field => _field;

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/ComparisonExpressionToFilterTranslator.cs

@@ -61,9 +61,9 @@ public static AstFilter Translate(TranslationContext context, BinaryExpression e
                 return ModuloComparisonExpressionToFilterTranslator.Translate(context, expression, moduloExpression, remainderExpression);
             }
 
-            if (StringExpressionToRegexFilterTranslator.CanTranslateComparisonExpression(leftExpression, comparisonOperator, rightExpression))
+            if (StringExpressionToRegexFilterTranslator.TryTranslateComparisonExpression(context, expression, leftExpression, comparisonOperator, rightExpression, out var filter))
             {
-                return StringExpressionToRegexFilterTranslator.TranslateComparisonExpression(context, expression, leftExpression, comparisonOperator, rightExpression);
+                return filter;
             }
 
             var comparand = rightExpression.GetConstantValue<object>(containingExpression: expression);

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/StringExpressionToRegexFilterTranslator.cs

@@ -21,6 +21,7 @@
 using System.Text;
 using System.Text.RegularExpressions;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Filters;
 using MongoDB.Driver.Linq.Linq3Implementation.ExtensionMethods;
 using MongoDB.Driver.Linq.Linq3Implementation.Misc;
@@ -147,33 +148,33 @@ public static bool CanTranslate(Expression expression)
             return false;
         }
 
-        // caller is responsible for ensuring constant is on the right
-        public static bool CanTranslateComparisonExpression(Expression leftExpression, AstComparisonFilterOperator comparisonOperator, Expression rightExpression)
+        public static bool TryTranslate(TranslationContext context, Expression expression, out AstFilter filter)
         {
-            // (int)document.S[i] == c
-            if (IsGetCharsComparison(leftExpression))
+            try
             {
+                filter = Translate(context, expression);
                 return true;
             }
-
-            // document.S == "abc"
-            if (IsStringComparison(leftExpression))
+            catch (ExpressionNotSupportedException)
             {
-                return true;
+                filter = null;
+                return false;
             }
+        }
 
-            // document.S.IndexOf('a') == n etc...
-            if (IsStringIndexOfComparison(leftExpression))
+        // caller is responsible for ensuring constant is on the right
+        public static bool TryTranslateComparisonExpression(TranslationContext context, Expression expression, Expression leftExpression, AstComparisonFilterOperator comparisonOperator, Expression rightExpression, out AstFilter filter)
+        {
+            try
             {
+                filter = TranslateComparisonExpression(context, expression, leftExpression, comparisonOperator, rightExpression);
                 return true;
             }
-            // document.S.Length == n or document.S.Count() == n
-            if (IsStringLengthComparison(leftExpression) || IsStringCountComparison(leftExpression))
+            catch (ExpressionNotSupportedException)
             {
-                return true;
+                filter = null;
+                return false;
             }
-
-            return false;
         }
 
         public static AstFilter Translate(TranslationContext context, Expression expression)
@@ -362,7 +363,7 @@ private static AstFilter TranslateGetCharsComparison(TranslationContext context,
             var leftConvertExpression = (UnaryExpression)leftExpression;
             var leftGetCharsExpression = (MethodCallExpression)leftConvertExpression.Operand;
             var fieldExpression = leftGetCharsExpression.Object;
-            var (field, modifiers) = TranslateField(context, fieldExpression);
+            var (field, modifiers) = TranslateField(context, expression, fieldExpression);
 
             var indexExpression = leftGetCharsExpression.Arguments[0];
             var index = indexExpression.GetConstantValue<int>(containingExpression: expression);
@@ -383,18 +384,25 @@ private static AstFilter TranslateGetCharsComparison(TranslationContext context,
             throw new ExpressionNotSupportedException(expression);
         }
 
-        private static (AstFilterField, Modifiers) TranslateField(TranslationContext context, Expression fieldExpression)
+        private static (AstFilterField, Modifiers) TranslateField(TranslationContext context, Expression expression, Expression fieldExpression)
         {
             if (fieldExpression is MethodCallExpression fieldMethodCallExpression &&
                 fieldMethodCallExpression.Method.IsOneOf(__modifierMethods))
             {
-                var (field, modifiers) = TranslateField(context, fieldMethodCallExpression.Object);
+                var (field, modifiers) = TranslateField(context, expression, fieldMethodCallExpression.Object);
                 modifiers = TranslateModifier(modifiers, fieldMethodCallExpression);
                 return (field, modifiers);
             }
             else
             {
                 var field = ExpressionToFilterFieldTranslator.Translate(context, fieldExpression);
+
+                if (field.Serializer is IRepresentationConfigurable representationConfigurable &&
+                    representationConfigurable.Representation != BsonType.String)
+                {
+                    throw new ExpressionNotSupportedException(fieldExpression, expression, because: $"field \"{field.Path}\" is not represented as a string");
+                }
+
                 return (field, new Modifiers());
             }
         }
@@ -424,7 +432,7 @@ private static AstFilter TranslateStartsWithOrContainsOrEndsWith(TranslationCont
             var method = expression.Method;
             var arguments = expression.Arguments;
 
-            var (field, modifiers) = TranslateField(context, expression.Object);
+            var (field, modifiers) = TranslateField(context, expression, expression.Object);
             var value = arguments[0].GetConstantValue<string>(containingExpression: expression);
             if (method.IsOneOf(StringMethod.StartsWithWithComparisonType, StringMethod.EndsWithWithComparisonType))
             {
@@ -466,7 +474,7 @@ bool IsImpossibleMatch(Modifiers modifiers, string value)
 
         private static AstFilter TranslateStringComparison(TranslationContext context, Expression expression, Expression leftExpression, AstComparisonFilterOperator comparisonOperator, Expression rightExpression)
         {
-            var (field, modifiers) = TranslateField(context, leftExpression);
+            var (field, modifiers) = TranslateField(context, expression, leftExpression);
             var comparand = rightExpression.GetConstantValue<string>(containingExpression: expression);
 
             if (comparisonOperator == AstComparisonFilterOperator.Eq || comparisonOperator == AstComparisonFilterOperator.Ne)
@@ -513,7 +521,7 @@ private static AstFilter TranslateStringIndexOfComparison(TranslationContext con
             var arguments = leftMethodCallExpression.Arguments;
 
             var fieldExpression = leftMethodCallExpression.Object;
-            var (field, modifiers) = TranslateField(context, fieldExpression);
+            var (field, modifiers) = TranslateField(context, expression, fieldExpression);
 
             var startIndex = 0;
             if (method.IsOneOf(__indexOfWithStartIndexMethods))
@@ -653,7 +661,7 @@ private static AstFilter TranslateStringLengthComparison(TranslationContext cont
                 throw new ExpressionNotSupportedException(expression);
             }
 
-            var (field, modifiers) = TranslateField(context, fieldExpression);
+            var (field, modifiers) = TranslateField(context, expression, fieldExpression);
 
             var comparand = rightExpression.GetConstantValue<int>(containingExpression: expression);
             var pattern = comparisonOperator switch

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/ContainsMethodToFilterTranslator.cs

@@ -28,9 +28,9 @@ internal static class ContainsMethodToFilterTranslator
     {
         public static AstFilter Translate(TranslationContext context, MethodCallExpression expression)
         {
-            if (StringExpressionToRegexFilterTranslator.CanTranslate(expression))
+            if (StringExpressionToRegexFilterTranslator.TryTranslate(context, expression, out var filter))
             {
-                return StringExpressionToRegexFilterTranslator.Translate(context, expression);
+                return filter;
             }
 
             var method = expression.Method;

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/EqualsMethodToFilterTranslator.cs

@@ -65,9 +65,9 @@ private static AstFilter Translate(TranslationContext context, Expression expres
                 (fieldExpression, valueExpression) = (expression1, expression2);
             }
 
-            if (StringExpressionToRegexFilterTranslator.CanTranslateComparisonExpression(fieldExpression, AstComparisonFilterOperator.Eq, valueExpression))
+            if (StringExpressionToRegexFilterTranslator.TryTranslateComparisonExpression(context, expression, fieldExpression, AstComparisonFilterOperator.Eq, valueExpression, out var filter))
             {
-                return StringExpressionToRegexFilterTranslator.TranslateComparisonExpression(context, expression, fieldExpression, AstComparisonFilterOperator.Eq, valueExpression);
+                return filter;
             }
 
             var field = ExpressionToFilterFieldTranslator.Translate(context, fieldExpression);

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/IsMatchMethodToFilterTranslator.cs

@@ -16,6 +16,7 @@
 using System.Linq.Expressions;
 using System.Text.RegularExpressions;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Filters;
 using MongoDB.Driver.Linq.Linq3Implementation.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
@@ -30,7 +31,7 @@ public static AstFilter Translate(TranslationContext context, MethodCallExpressi
         {
             if (IsMatchMethod(expression, out var inputExpression, out var regularExpression))
             {
-                return Translate(context, inputExpression, regularExpression);
+                return Translate(context, expression, inputExpression, regularExpression);
             }
 
             throw new ExpressionNotSupportedException(expression);
@@ -92,10 +93,17 @@ private static bool IsMatchMethod(MethodCallExpression expression, out Expressio
             return false;
         }
 
-        private static AstFilter Translate(TranslationContext context, Expression inputExpression, Regex regex)
+        private static AstFilter Translate(TranslationContext context, Expression expression, Expression inputExpression, Regex regex)
         {
             var inputFieldAst = ExpressionToFilterFieldTranslator.Translate(context, inputExpression);
             var regularExpression = new BsonRegularExpression(regex);
+
+            if (inputFieldAst.Serializer is IRepresentationConfigurable representationConfigurable &&
+                representationConfigurable.Representation != BsonType.String)
+            {
+                throw new ExpressionNotSupportedException(inputExpression, expression, because: $"field \"{inputFieldAst.Path}\" is not represented as a string");
+            }
+
             return AstFilter.Regex(inputFieldAst, regularExpression.Pattern, regularExpression.Options);
         }
     }

tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Jira/CSharp4066Tests.cs

@@ -0,0 +1,57 @@
+/* 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 FluentAssertions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3ImplementationTests.Jira
+{
+    public class CSharp4066Tests : Linq3IntegrationTest
+    {
+        [Fact]
+        public void String_comparison_in_filter_should_use_custom_serializer()
+        {
+            var collection = GetCollection<C>();
+            collection.Database.DropCollection(collection.CollectionNamespace.CollectionName);
+
+            var id = "0102030405060708090a0b0c";
+            collection.InsertMany(
+                new[]
+                {
+                    new C { Id = id, X = 1 },
+                    new C { Id = "000000000000000000000000", X = 2 }
+                });
+
+            var find = collection.Find(x => x.Id == id);
+
+            var rendered = find.ToString();
+            rendered.Should().Be("find({ \"_id\" : ObjectId(\"0102030405060708090a0b0c\") })");
+
+            var results = find.ToList();
+            results.Count.Should().Be(1);
+            results[0].Id.Should().Be(id);
+            results[0].X.Should().Be(1);
+        }
+
+        public class C
+        {
+            [BsonRepresentation(BsonType.ObjectId)]
+            public string Id { get; set; }
+            public int X { get; set; }
+        }
+    }
+}