CSHARP-1622: added support for $substrCP.

craiggwilson · rstam · commit 01b378f52980 · 2016-09-24T18:26:34.000-04:00
diff --git a/src/MongoDB.Driver/AggregateOptions.cs b/src/MongoDB.Driver/AggregateOptions.cs
@@ -32,6 +32,7 @@ public class AggregateOptions
         private int? _batchSize;
         private bool? _bypassDocumentValidation;
         private TimeSpan? _maxTime;
+        private ExpressionTranslationOptions _translationOptions;
         private bool? _useCursor;
 
         // properties
@@ -71,6 +72,15 @@ public TimeSpan? MaxTime
             set { _maxTime = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the translation options.
+        /// </summary>
+        public ExpressionTranslationOptions TranslationOptions
+        {
+            get { return _translationOptions; }
+            set { _translationOptions = value; }
+        }
+
         /// <summary>
         /// Gets or sets a value indicating whether to use a cursor.
         /// </summary>
diff --git a/src/MongoDB.Driver/AggregateStringTranslationMode.cs b/src/MongoDB.Driver/AggregateStringTranslationMode.cs
@@ -0,0 +1,33 @@
+﻿/* Copyright 2016 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.
+* 
+*/
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Option for which expression to generate for certain string operations.
+    /// </summary>
+    public enum AggregateStringTranslationMode
+    {
+        /// <summary>
+        /// Translate to the byte variation.
+        /// </summary>
+        Bytes,
+        /// <summary>
+        /// Translate to the code points variation. This is only supported in >= MongoDB 3.4.
+        /// </summary>
+        CodePoints
+    }
+}
diff --git a/src/MongoDB.Driver/ExpressionTranslationOptions.cs b/src/MongoDB.Driver/ExpressionTranslationOptions.cs
@@ -0,0 +1,31 @@
+﻿/* Copyright 2016 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.
+* 
+*/
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Options for controlling translation from .NET expression trees into MongoDB expressions.
+    /// </summary>
+    public class ExpressionTranslationOptions
+    {
+        internal static ExpressionTranslationOptions Default = new ExpressionTranslationOptions();
+
+        /// <summary>
+        /// Gets or sets the string translation mode.
+        /// </summary>
+        public AggregateStringTranslationMode? StringTranslationMode { get; set; }
+    }
+}
diff --git a/src/MongoDB.Driver/IAggregateFluentExtensions.cs b/src/MongoDB.Driver/IAggregateFluentExtensions.cs
@@ -66,7 +66,7 @@ public static IAggregateFluent<TNewResult> Group<TResult, TKey, TNewResult>(this
             Ensure.IsNotNull(id, nameof(id));
             Ensure.IsNotNull(group, nameof(group));
 
-            return aggregate.Group<TNewResult>(new GroupExpressionProjection<TResult, TKey, TNewResult>(id, group));
+            return aggregate.Group<TNewResult>(new GroupExpressionProjection<TResult, TKey, TNewResult>(id, group, aggregate.Options.TranslationOptions));
         }
 
         /// <summary>
@@ -188,7 +188,7 @@ public static IAggregateFluent<TNewResult> Project<TResult, TNewResult>(this IAg
             Ensure.IsNotNull(aggregate, nameof(aggregate));
             Ensure.IsNotNull(projection, nameof(projection));
 
-            return aggregate.Project<TNewResult>(new ProjectExpressionProjection<TResult, TNewResult>(projection));
+            return aggregate.Project<TNewResult>(new ProjectExpressionProjection<TResult, TNewResult>(projection, aggregate.Options.TranslationOptions));
         }
 
         /// <summary>
@@ -501,10 +501,12 @@ public static IAggregateFluent<TNewResult> Unwind<TResult, TNewResult>(this IAgg
         private sealed class ProjectExpressionProjection<TResult, TNewResult> : ProjectionDefinition<TResult, TNewResult>
         {
             private readonly Expression<Func<TResult, TNewResult>> _expression;
+            private readonly ExpressionTranslationOptions _translationOptions;
 
-            public ProjectExpressionProjection(Expression<Func<TResult, TNewResult>> expression)
+            public ProjectExpressionProjection(Expression<Func<TResult, TNewResult>> expression, ExpressionTranslationOptions translationOptions)
             {
                 _expression = Ensure.IsNotNull(expression, nameof(expression));
+                _translationOptions = translationOptions;
             }
 
             public Expression<Func<TResult, TNewResult>> Expression
@@ -514,19 +516,21 @@ public Expression<Func<TResult, TNewResult>> Expression
 
             public override RenderedProjectionDefinition<TNewResult> Render(IBsonSerializer<TResult> documentSerializer, IBsonSerializerRegistry serializerRegistry)
             {
-                return AggregateProjectTranslator.Translate<TResult, TNewResult>(_expression, documentSerializer, serializerRegistry);
+                return AggregateProjectTranslator.Translate<TResult, TNewResult>(_expression, documentSerializer, serializerRegistry, _translationOptions);
             }
         }
 
         private sealed class GroupExpressionProjection<TResult, TKey, TNewResult> : ProjectionDefinition<TResult, TNewResult>
         {
             private readonly Expression<Func<TResult, TKey>> _idExpression;
             private readonly Expression<Func<IGrouping<TKey, TResult>, TNewResult>> _groupExpression;
+            private readonly ExpressionTranslationOptions _translationOptions;
 
-            public GroupExpressionProjection(Expression<Func<TResult, TKey>> idExpression, Expression<Func<IGrouping<TKey, TResult>, TNewResult>> groupExpression)
+            public GroupExpressionProjection(Expression<Func<TResult, TKey>> idExpression, Expression<Func<IGrouping<TKey, TResult>, TNewResult>> groupExpression, ExpressionTranslationOptions translationOptions)
             {
                 _idExpression = Ensure.IsNotNull(idExpression, nameof(idExpression));
                 _groupExpression = Ensure.IsNotNull(groupExpression, nameof(groupExpression));
+                _translationOptions = translationOptions;
             }
 
             public Expression<Func<TResult, TKey>> IdExpression
@@ -541,7 +545,7 @@ public Expression<Func<IGrouping<TKey, TResult>, TNewResult>> GroupExpression
 
             public override RenderedProjectionDefinition<TNewResult> Render(IBsonSerializer<TResult> documentSerializer, IBsonSerializerRegistry serializerRegistry)
             {
-                return AggregateGroupTranslator.Translate<TKey, TResult, TNewResult>(_idExpression, _groupExpression, documentSerializer, serializerRegistry);
+                return AggregateGroupTranslator.Translate<TKey, TResult, TNewResult>(_idExpression, _groupExpression, documentSerializer, serializerRegistry, _translationOptions);
             }
         }
     }
diff --git a/src/MongoDB.Driver/Linq/MongoQueryProviderImpl.cs b/src/MongoDB.Driver/Linq/MongoQueryProviderImpl.cs
@@ -127,7 +127,7 @@ private Expression Prepare(Expression expression)
         private QueryableTranslation Translate(Expression expression)
         {
             var pipelineExpression = Prepare(expression);
-            return QueryableTranslator.Translate(pipelineExpression, _collection.Settings.SerializerRegistry);
+            return QueryableTranslator.Translate(pipelineExpression, _collection.Settings.SerializerRegistry, _options.TranslationOptions);
         }
     }
 }
diff --git a/src/MongoDB.Driver/Linq/Translators/AggregateGroupTranslator.cs b/src/MongoDB.Driver/Linq/Translators/AggregateGroupTranslator.cs
@@ -28,20 +28,20 @@ namespace MongoDB.Driver.Linq.Translators
 {
     internal static class AggregateGroupTranslator
     {
-        public static RenderedProjectionDefinition<TResult> Translate<TKey, TDocument, TResult>(Expression<Func<TDocument, TKey>> idProjector, Expression<Func<IGrouping<TKey, TDocument>, TResult>> groupProjector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry)
+        public static RenderedProjectionDefinition<TResult> Translate<TKey, TDocument, TResult>(Expression<Func<TDocument, TKey>> idProjector, Expression<Func<IGrouping<TKey, TDocument>, TResult>> groupProjector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)
         {
             var bindingContext = new PipelineBindingContext(serializerRegistry);
 
             var keySelector = BindKeySelector(bindingContext, idProjector, parameterSerializer);
             var boundGroupExpression = BindGroup(bindingContext, groupProjector, parameterSerializer, keySelector);
 
             var projectionSerializer = bindingContext.GetSerializer(boundGroupExpression.Type, boundGroupExpression);
-            var projection = AggregateLanguageTranslator.Translate(boundGroupExpression).AsBsonDocument;
+            var projection = AggregateLanguageTranslator.Translate(boundGroupExpression, translationOptions).AsBsonDocument;
 
             // must have an "_id" in a group document
             if (!projection.Contains("_id"))
             {
-                var idProjection = AggregateLanguageTranslator.Translate(keySelector);
+                var idProjection = AggregateLanguageTranslator.Translate(keySelector, translationOptions);
                 projection.InsertAt(0, new BsonElement("_id", idProjection));
             }
 
diff --git a/src/MongoDB.Driver/Linq/Translators/AggregateLanguageTranslator.cs b/src/MongoDB.Driver/Linq/Translators/AggregateLanguageTranslator.cs
@@ -31,14 +31,18 @@ namespace MongoDB.Driver.Linq.Translators
 {
     internal sealed class AggregateLanguageTranslator
     {
-        public static BsonValue Translate(Expression node)
+        public static BsonValue Translate(Expression node, ExpressionTranslationOptions translationOptions)
         {
-            var builder = new AggregateLanguageTranslator();
+            var builder = new AggregateLanguageTranslator(translationOptions);
             return builder.TranslateValue(node);
         }
 
-        private AggregateLanguageTranslator()
+        private readonly AggregateStringTranslationMode _stringTranslationMode;
+
+        private AggregateLanguageTranslator(ExpressionTranslationOptions translationOptions)
         {
+            translationOptions = translationOptions ?? ExpressionTranslationOptions.Default;
+            _stringTranslationMode = translationOptions.StringTranslationMode.GetValueOrDefault(AggregateStringTranslationMode.Bytes);
         }
 
         private BsonValue TranslateValue(Expression node)
@@ -1119,7 +1123,12 @@ private bool TryTranslateStringMethodCall(MethodCallExpression node, out BsonVal
                 case "Substring":
                     if (node.Arguments.Count == 2)
                     {
-                        result = new BsonDocument("$substr", new BsonArray(new[]
+                        var name = "$substr";
+                        if (_stringTranslationMode == AggregateStringTranslationMode.CodePoints)
+                        {
+                            name = "$substrCP";
+                        }
+                        result = new BsonDocument(name, new BsonArray(new[]
                             {
                                 field,
                                 TranslateValue(node.Arguments[0]),
diff --git a/src/MongoDB.Driver/Linq/Translators/AggregateProjectTranslator.cs b/src/MongoDB.Driver/Linq/Translators/AggregateProjectTranslator.cs
@@ -25,7 +25,7 @@ namespace MongoDB.Driver.Linq.Translators
 {
     internal static class AggregateProjectTranslator
     {
-        public static RenderedProjectionDefinition<TResult> Translate<TDocument, TResult>(Expression<Func<TDocument, TResult>> projector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry)
+        public static RenderedProjectionDefinition<TResult> Translate<TDocument, TResult>(Expression<Func<TDocument, TResult>> projector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)
         {
             var bindingContext = new PipelineBindingContext(serializerRegistry);
             var parameterExpression = new DocumentExpression(parameterSerializer);
@@ -36,14 +36,14 @@ public static RenderedProjectionDefinition<TResult> Translate<TDocument, TResult
             node = bindingContext.Bind(node);
 
             var projectionSerializer = bindingContext.GetSerializer(node.Type, node);
-            var projection = TranslateProject(node);
+            var projection = TranslateProject(node, translationOptions);
 
             return new RenderedProjectionDefinition<TResult>(projection, (IBsonSerializer<TResult>)projectionSerializer);
         }
 
-        public static BsonDocument TranslateProject(Expression expression)
+        public static BsonDocument TranslateProject(Expression expression, ExpressionTranslationOptions translationOptions)
         {
-            var projection = (BsonDocument)AggregateLanguageTranslator.Translate(expression);
+            var projection = (BsonDocument)AggregateLanguageTranslator.Translate(expression, translationOptions);
             if (!projection.Contains("_id"))
             {
                 projection.Add("_id", 0);
diff --git a/src/MongoDB.Driver/Linq/Translators/QueryableTranslator.cs b/src/MongoDB.Driver/Linq/Translators/QueryableTranslator.cs
@@ -30,9 +30,9 @@ namespace MongoDB.Driver.Linq.Translators
 {
     internal sealed class QueryableTranslator
     {
-        public static QueryableTranslation Translate(Expression node, IBsonSerializerRegistry serializerRegistry)
+        public static QueryableTranslation Translate(Expression node, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)
         {
-            var translator = new QueryableTranslator(serializerRegistry);
+            var translator = new QueryableTranslator(serializerRegistry, translationOptions);
             translator.Translate(node);
 
             var outputType = translator._outputSerializer.ValueType;
@@ -53,10 +53,12 @@ public static QueryableTranslation Translate(Expression node, IBsonSerializerReg
         private readonly IBsonSerializerRegistry _serializerRegistry;
         private readonly List<BsonDocument> _stages;
         private IResultTransformer _resultTransformer;
+        private ExpressionTranslationOptions _translationOptions;
 
-        public QueryableTranslator(IBsonSerializerRegistry serializerRegistry)
+        public QueryableTranslator(IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)
         {
             _serializerRegistry = Ensure.IsNotNull(serializerRegistry, nameof(serializerRegistry));
+            _translationOptions = Ensure.IsNotNull(translationOptions, nameof(translationOptions));
             _stages = new List<BsonDocument>();
         }
 
@@ -119,11 +121,11 @@ private void TranslateGroupBy(GroupByExpression node)
             Translate(node.Source);
 
             var groupValue = new BsonDocument();
-            var idValue = AggregateLanguageTranslator.Translate(node.KeySelector);
+            var idValue = AggregateLanguageTranslator.Translate(node.KeySelector, _translationOptions);
             groupValue.Add("_id", idValue);
             foreach (var accumulator in node.Accumulators)
             {
-                var accumulatorValue = AggregateLanguageTranslator.Translate(accumulator);
+                var accumulatorValue = AggregateLanguageTranslator.Translate(accumulator, _translationOptions);
                 groupValue.Add(accumulator.FieldName, accumulatorValue);
             }
 
@@ -148,15 +150,15 @@ private void TranslateGroupJoin(GroupJoinExpression node)
                 throw new NotSupportedException("Only a collection is allowed to be joined.");
             }
 
-            var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector);
+            var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector, _translationOptions);
             if (localFieldValue.BsonType != BsonType.String)
             {
                 throw new NotSupportedException("Could not translate the local field.");
             }
 
             var localField = localFieldValue.ToString().Substring(1); // remove '$'
 
-            var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector);
+            var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector, _translationOptions);
             if (foreignFieldValue.BsonType != BsonType.String)
             {
                 throw new NotSupportedException("Could not translate the foreign field.");
@@ -183,15 +185,15 @@ private void TranslateJoin(JoinExpression node)
                 throw new NotSupportedException("Only a collection is allowed to be joined.");
             }
 
-            var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector);
+            var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector, _translationOptions);
             if (localFieldValue.BsonType != BsonType.String)
             {
                 throw new NotSupportedException("Could not translate the local field.");
             }
 
             var localField = localFieldValue.ToString().Substring(1); // remove '$'
 
-            var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector);
+            var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector, _translationOptions);
             if (foreignFieldValue.BsonType != BsonType.String)
             {
                 throw new NotSupportedException("Could not translate the foreign field.");
@@ -367,7 +369,7 @@ private void TranslateWhere(WhereExpression node)
         private BsonDocument TranslateProjectValue(Expression selector)
         {
             BsonDocument projectValue;
-            var result = AggregateLanguageTranslator.Translate(selector);
+            var result = AggregateLanguageTranslator.Translate(selector, _translationOptions);
             if (result.BsonType == BsonType.String)
             {
                 // this means we got back a field expression prefixed with a $ sign.
diff --git a/src/MongoDB.Driver/MongoDB.Driver.csproj b/src/MongoDB.Driver/MongoDB.Driver.csproj
@@ -76,6 +76,7 @@
     </Compile>
     <Compile Include="AggregateFluent.cs" />
     <Compile Include="AggregateLookupOptions.cs" />
+    <Compile Include="AggregateStringTranslationMode.cs" />
     <Compile Include="AsyncCursorHelper.cs" />
     <Compile Include="Builders.cs" />
     <Compile Include="CreateIndexModel.cs" />
@@ -255,6 +256,7 @@
     <Compile Include="Linq\Translators\ProjectedObjectDeserializer.cs" />
     <Compile Include="Linq\Translators\QueryableTranslator.cs" />
     <Compile Include="Linq\Translators\PredicateTranslator.cs" />
+    <Compile Include="ExpressionTranslationOptions.cs" />
     <Compile Include="OfTypeSerializer.cs" />
     <Compile Include="PipelineStageDefinition.cs" />
     <Compile Include="PipelineDefinition.cs" />
diff --git a/tests/MongoDB.Driver.Tests/Linq/Translators/AggregateGroupTranslatorTests.cs b/tests/MongoDB.Driver.Tests/Linq/Translators/AggregateGroupTranslatorTests.cs
@@ -368,9 +368,14 @@ public void Should_translate_aggregate_expressions_with_user_provided_serializer
         }
 
         private ProjectedResult<TResult> Group<TKey, TResult>(Expression<Func<Root, TKey>> idProjector, Expression<Func<IGrouping<TKey, Root>, TResult>> groupProjector)
+        {
+            return Group(idProjector, groupProjector, null);
+        }
+
+        private ProjectedResult<TResult> Group<TKey, TResult>(Expression<Func<Root, TKey>> idProjector, Expression<Func<IGrouping<TKey, Root>, TResult>> groupProjector, ExpressionTranslationOptions translationOptions)
         {
             var serializer = BsonSerializer.SerializerRegistry.GetSerializer<Root>();
-            var projectionInfo = AggregateGroupTranslator.Translate<TKey, Root, TResult>(idProjector, groupProjector, serializer, BsonSerializer.SerializerRegistry);
+            var projectionInfo = AggregateGroupTranslator.Translate<TKey, Root, TResult>(idProjector, groupProjector, serializer, BsonSerializer.SerializerRegistry, translationOptions);
 
             var group = new BsonDocument("$group", projectionInfo.Document);
             var sort = new BsonDocument("$sort", new BsonDocument("_id", 1));
diff --git a/tests/MongoDB.Driver.Tests/Linq/Translators/AggregateProjectTranslatorTests.cs b/tests/MongoDB.Driver.Tests/Linq/Translators/AggregateProjectTranslatorTests.cs

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public static IAggregateFluent<TNewResult> Group<TResult, TKey, TNewResult>(this`
`66`	`66`	`Ensure.IsNotNull(id, nameof(id));`
`67`	`67`	`Ensure.IsNotNull(group, nameof(group));`
`68`	`68`
`69`		`- return aggregate.Group<TNewResult>(new GroupExpressionProjection<TResult, TKey, TNewResult>(id, group));`
	`69`	`+ return aggregate.Group<TNewResult>(new GroupExpressionProjection<TResult, TKey, TNewResult>(id, group, aggregate.Options.TranslationOptions));`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`/// <summary>`
`@@ -188,7 +188,7 @@ public static IAggregateFluent<TNewResult> Project<TResult, TNewResult>(this IAg`
`188`	`188`	`Ensure.IsNotNull(aggregate, nameof(aggregate));`
`189`	`189`	`Ensure.IsNotNull(projection, nameof(projection));`
`190`	`190`
`191`		`- return aggregate.Project<TNewResult>(new ProjectExpressionProjection<TResult, TNewResult>(projection));`
	`191`	`+ return aggregate.Project<TNewResult>(new ProjectExpressionProjection<TResult, TNewResult>(projection, aggregate.Options.TranslationOptions));`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`/// <summary>`
`@@ -501,10 +501,12 @@ public static IAggregateFluent<TNewResult> Unwind<TResult, TNewResult>(this IAgg`
`501`	`501`	`private sealed class ProjectExpressionProjection<TResult, TNewResult> : ProjectionDefinition<TResult, TNewResult>`
`502`	`502`	`{`
`503`	`503`	`private readonly Expression<Func<TResult, TNewResult>> _expression;`
	`504`	`+ private readonly ExpressionTranslationOptions _translationOptions;`
`504`	`505`
`505`		`- public ProjectExpressionProjection(Expression<Func<TResult, TNewResult>> expression)`
	`506`	`+ public ProjectExpressionProjection(Expression<Func<TResult, TNewResult>> expression, ExpressionTranslationOptions translationOptions)`
`506`	`507`	`{`
`507`	`508`	`_expression = Ensure.IsNotNull(expression, nameof(expression));`
	`509`	`+ _translationOptions = translationOptions;`
`508`	`510`	`}`
`509`	`511`
`510`	`512`	`public Expression<Func<TResult, TNewResult>> Expression`
`@@ -514,19 +516,21 @@ public Expression<Func<TResult, TNewResult>> Expression`
`514`	`516`
`515`	`517`	`public override RenderedProjectionDefinition<TNewResult> Render(IBsonSerializer<TResult> documentSerializer, IBsonSerializerRegistry serializerRegistry)`
`516`	`518`	`{`
`517`		`- return AggregateProjectTranslator.Translate<TResult, TNewResult>(_expression, documentSerializer, serializerRegistry);`
	`519`	`+ return AggregateProjectTranslator.Translate<TResult, TNewResult>(_expression, documentSerializer, serializerRegistry, _translationOptions);`
`518`	`520`	`}`
`519`	`521`	`}`
`520`	`522`
`521`	`523`	`private sealed class GroupExpressionProjection<TResult, TKey, TNewResult> : ProjectionDefinition<TResult, TNewResult>`
`522`	`524`	`{`
`523`	`525`	`private readonly Expression<Func<TResult, TKey>> _idExpression;`
`524`	`526`	`private readonly Expression<Func<IGrouping<TKey, TResult>, TNewResult>> _groupExpression;`
	`527`	`+ private readonly ExpressionTranslationOptions _translationOptions;`
`525`	`528`
`526`		`- public GroupExpressionProjection(Expression<Func<TResult, TKey>> idExpression, Expression<Func<IGrouping<TKey, TResult>, TNewResult>> groupExpression)`
	`529`	`+ public GroupExpressionProjection(Expression<Func<TResult, TKey>> idExpression, Expression<Func<IGrouping<TKey, TResult>, TNewResult>> groupExpression, ExpressionTranslationOptions translationOptions)`
`527`	`530`	`{`
`528`	`531`	`_idExpression = Ensure.IsNotNull(idExpression, nameof(idExpression));`
`529`	`532`	`_groupExpression = Ensure.IsNotNull(groupExpression, nameof(groupExpression));`
	`533`	`+ _translationOptions = translationOptions;`
`530`	`534`	`}`
`531`	`535`
`532`	`536`	`public Expression<Func<TResult, TKey>> IdExpression`
`@@ -541,7 +545,7 @@ public Expression<Func<IGrouping<TKey, TResult>, TNewResult>> GroupExpression`
`541`	`545`
`542`	`546`	`public override RenderedProjectionDefinition<TNewResult> Render(IBsonSerializer<TResult> documentSerializer, IBsonSerializerRegistry serializerRegistry)`
`543`	`547`	`{`
`544`		`- return AggregateGroupTranslator.Translate<TKey, TResult, TNewResult>(_idExpression, _groupExpression, documentSerializer, serializerRegistry);`
	`548`	`+ return AggregateGroupTranslator.Translate<TKey, TResult, TNewResult>(_idExpression, _groupExpression, documentSerializer, serializerRegistry, _translationOptions);`
`545`	`549`	`}`
`546`	`550`	`}`
`547`	`551`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ private Expression Prepare(Expression expression)`
`127`	`127`	`private QueryableTranslation Translate(Expression expression)`
`128`	`128`	`{`
`129`	`129`	`var pipelineExpression = Prepare(expression);`
`130`		`- return QueryableTranslator.Translate(pipelineExpression, _collection.Settings.SerializerRegistry);`
	`130`	`+ return QueryableTranslator.Translate(pipelineExpression, _collection.Settings.SerializerRegistry, _options.TranslationOptions);`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,20 +28,20 @@ namespace MongoDB.Driver.Linq.Translators`
`28`	`28`	`{`
`29`	`29`	`internal static class AggregateGroupTranslator`
`30`	`30`	`{`
`31`		`- public static RenderedProjectionDefinition<TResult> Translate<TKey, TDocument, TResult>(Expression<Func<TDocument, TKey>> idProjector, Expression<Func<IGrouping<TKey, TDocument>, TResult>> groupProjector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry)`
	`31`	`+ public static RenderedProjectionDefinition<TResult> Translate<TKey, TDocument, TResult>(Expression<Func<TDocument, TKey>> idProjector, Expression<Func<IGrouping<TKey, TDocument>, TResult>> groupProjector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)`
`32`	`32`	`{`
`33`	`33`	`var bindingContext = new PipelineBindingContext(serializerRegistry);`
`34`	`34`
`35`	`35`	`var keySelector = BindKeySelector(bindingContext, idProjector, parameterSerializer);`
`36`	`36`	`var boundGroupExpression = BindGroup(bindingContext, groupProjector, parameterSerializer, keySelector);`
`37`	`37`
`38`	`38`	`var projectionSerializer = bindingContext.GetSerializer(boundGroupExpression.Type, boundGroupExpression);`
`39`		`- var projection = AggregateLanguageTranslator.Translate(boundGroupExpression).AsBsonDocument;`
	`39`	`+ var projection = AggregateLanguageTranslator.Translate(boundGroupExpression, translationOptions).AsBsonDocument;`
`40`	`40`
`41`	`41`	`// must have an "_id" in a group document`
`42`	`42`	`if (!projection.Contains("_id"))`
`43`	`43`	`{`
`44`		`- var idProjection = AggregateLanguageTranslator.Translate(keySelector);`
	`44`	`+ var idProjection = AggregateLanguageTranslator.Translate(keySelector, translationOptions);`
`45`	`45`	`projection.InsertAt(0, new BsonElement("_id", idProjection));`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -31,14 +31,18 @@ namespace MongoDB.Driver.Linq.Translators`
`31`	`31`	`{`
`32`	`32`	`internal sealed class AggregateLanguageTranslator`
`33`	`33`	`{`
`34`		`- public static BsonValue Translate(Expression node)`
	`34`	`+ public static BsonValue Translate(Expression node, ExpressionTranslationOptions translationOptions)`
`35`	`35`	`{`
`36`		`- var builder = new AggregateLanguageTranslator();`
	`36`	`+ var builder = new AggregateLanguageTranslator(translationOptions);`
`37`	`37`	`return builder.TranslateValue(node);`
`38`	`38`	`}`
`39`	`39`
`40`		`- private AggregateLanguageTranslator()`
	`40`	`+ private readonly AggregateStringTranslationMode _stringTranslationMode;`
	`41`	`+`
	`42`	`+ private AggregateLanguageTranslator(ExpressionTranslationOptions translationOptions)`
`41`	`43`	`{`
	`44`	`+ translationOptions = translationOptions ?? ExpressionTranslationOptions.Default;`
	`45`	`+ _stringTranslationMode = translationOptions.StringTranslationMode.GetValueOrDefault(AggregateStringTranslationMode.Bytes);`
`42`	`46`	`}`
`43`	`47`
`44`	`48`	`private BsonValue TranslateValue(Expression node)`
`@@ -1119,7 +1123,12 @@ private bool TryTranslateStringMethodCall(MethodCallExpression node, out BsonVal`
`1119`	`1123`	`case "Substring":`
`1120`	`1124`	`if (node.Arguments.Count == 2)`
`1121`	`1125`	`{`
`1122`		`- result = new BsonDocument("$substr", new BsonArray(new[]`
	`1126`	`+ var name = "$substr";`
	`1127`	`+ if (_stringTranslationMode == AggregateStringTranslationMode.CodePoints)`
	`1128`	`+ {`
	`1129`	`+ name = "$substrCP";`
	`1130`	`+ }`
	`1131`	`+ result = new BsonDocument(name, new BsonArray(new[]`
`1123`	`1132`	`{`
`1124`	`1133`	`field,`
`1125`	`1134`	`TranslateValue(node.Arguments[0]),`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ namespace MongoDB.Driver.Linq.Translators`
`25`	`25`	`{`
`26`	`26`	`internal static class AggregateProjectTranslator`
`27`	`27`	`{`
`28`		`- public static RenderedProjectionDefinition<TResult> Translate<TDocument, TResult>(Expression<Func<TDocument, TResult>> projector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry)`
	`28`	`+ public static RenderedProjectionDefinition<TResult> Translate<TDocument, TResult>(Expression<Func<TDocument, TResult>> projector, IBsonSerializer<TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)`
`29`	`29`	`{`
`30`	`30`	`var bindingContext = new PipelineBindingContext(serializerRegistry);`
`31`	`31`	`var parameterExpression = new DocumentExpression(parameterSerializer);`
`@@ -36,14 +36,14 @@ public static RenderedProjectionDefinition<TResult> Translate<TDocument, TResult`
`36`	`36`	`node = bindingContext.Bind(node);`
`37`	`37`
`38`	`38`	`var projectionSerializer = bindingContext.GetSerializer(node.Type, node);`
`39`		`- var projection = TranslateProject(node);`
	`39`	`+ var projection = TranslateProject(node, translationOptions);`
`40`	`40`
`41`	`41`	`return new RenderedProjectionDefinition<TResult>(projection, (IBsonSerializer<TResult>)projectionSerializer);`
`42`	`42`	`}`
`43`	`43`
`44`		`- public static BsonDocument TranslateProject(Expression expression)`
	`44`	`+ public static BsonDocument TranslateProject(Expression expression, ExpressionTranslationOptions translationOptions)`
`45`	`45`	`{`
`46`		`- var projection = (BsonDocument)AggregateLanguageTranslator.Translate(expression);`
	`46`	`+ var projection = (BsonDocument)AggregateLanguageTranslator.Translate(expression, translationOptions);`
`47`	`47`	`if (!projection.Contains("_id"))`
`48`	`48`	`{`
`49`	`49`	`projection.Add("_id", 0);`
Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,9 @@ namespace MongoDB.Driver.Linq.Translators`
`30`	`30`	`{`
`31`	`31`	`internal sealed class QueryableTranslator`
`32`	`32`	`{`
`33`		`- public static QueryableTranslation Translate(Expression node, IBsonSerializerRegistry serializerRegistry)`
	`33`	`+ public static QueryableTranslation Translate(Expression node, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)`
`34`	`34`	`{`
`35`		`- var translator = new QueryableTranslator(serializerRegistry);`
	`35`	`+ var translator = new QueryableTranslator(serializerRegistry, translationOptions);`
`36`	`36`	`translator.Translate(node);`
`37`	`37`
`38`	`38`	`var outputType = translator._outputSerializer.ValueType;`
`@@ -53,10 +53,12 @@ public static QueryableTranslation Translate(Expression node, IBsonSerializerReg`
`53`	`53`	`private readonly IBsonSerializerRegistry _serializerRegistry;`
`54`	`54`	`private readonly List<BsonDocument> _stages;`
`55`	`55`	`private IResultTransformer _resultTransformer;`
	`56`	`+ private ExpressionTranslationOptions _translationOptions;`
`56`	`57`
`57`		`- public QueryableTranslator(IBsonSerializerRegistry serializerRegistry)`
	`58`	`+ public QueryableTranslator(IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)`
`58`	`59`	`{`
`59`	`60`	`_serializerRegistry = Ensure.IsNotNull(serializerRegistry, nameof(serializerRegistry));`
	`61`	`+ _translationOptions = Ensure.IsNotNull(translationOptions, nameof(translationOptions));`
`60`	`62`	`_stages = new List<BsonDocument>();`
`61`	`63`	`}`
`62`	`64`
`@@ -119,11 +121,11 @@ private void TranslateGroupBy(GroupByExpression node)`
`119`	`121`	`Translate(node.Source);`
`120`	`122`
`121`	`123`	`var groupValue = new BsonDocument();`
`122`		`- var idValue = AggregateLanguageTranslator.Translate(node.KeySelector);`
	`124`	`+ var idValue = AggregateLanguageTranslator.Translate(node.KeySelector, _translationOptions);`
`123`	`125`	`groupValue.Add("_id", idValue);`
`124`	`126`	`foreach (var accumulator in node.Accumulators)`
`125`	`127`	`{`
`126`		`- var accumulatorValue = AggregateLanguageTranslator.Translate(accumulator);`
	`128`	`+ var accumulatorValue = AggregateLanguageTranslator.Translate(accumulator, _translationOptions);`
`127`	`129`	`groupValue.Add(accumulator.FieldName, accumulatorValue);`
`128`	`130`	`}`
`129`	`131`
`@@ -148,15 +150,15 @@ private void TranslateGroupJoin(GroupJoinExpression node)`
`148`	`150`	`throw new NotSupportedException("Only a collection is allowed to be joined.");`
`149`	`151`	`}`
`150`	`152`
`151`		`- var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector);`
	`153`	`+ var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector, _translationOptions);`
`152`	`154`	`if (localFieldValue.BsonType != BsonType.String)`
`153`	`155`	`{`
`154`	`156`	`throw new NotSupportedException("Could not translate the local field.");`
`155`	`157`	`}`
`156`	`158`
`157`	`159`	`var localField = localFieldValue.ToString().Substring(1); // remove '$'`
`158`	`160`
`159`		`- var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector);`
	`161`	`+ var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector, _translationOptions);`
`160`	`162`	`if (foreignFieldValue.BsonType != BsonType.String)`
`161`	`163`	`{`
`162`	`164`	`throw new NotSupportedException("Could not translate the foreign field.");`
`@@ -183,15 +185,15 @@ private void TranslateJoin(JoinExpression node)`
`183`	`185`	`throw new NotSupportedException("Only a collection is allowed to be joined.");`
`184`	`186`	`}`
`185`	`187`
`186`		`- var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector);`
	`188`	`+ var localFieldValue = AggregateLanguageTranslator.Translate(node.SourceKeySelector, _translationOptions);`
`187`	`189`	`if (localFieldValue.BsonType != BsonType.String)`
`188`	`190`	`{`
`189`	`191`	`throw new NotSupportedException("Could not translate the local field.");`
`190`	`192`	`}`
`191`	`193`
`192`	`194`	`var localField = localFieldValue.ToString().Substring(1); // remove '$'`
`193`	`195`
`194`		`- var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector);`
	`196`	`+ var foreignFieldValue = AggregateLanguageTranslator.Translate(node.JoinedKeySelector, _translationOptions);`
`195`	`197`	`if (foreignFieldValue.BsonType != BsonType.String)`
`196`	`198`	`{`
`197`	`199`	`throw new NotSupportedException("Could not translate the foreign field.");`
`@@ -367,7 +369,7 @@ private void TranslateWhere(WhereExpression node)`
`367`	`369`	`private BsonDocument TranslateProjectValue(Expression selector)`
`368`	`370`	`{`
`369`	`371`	`BsonDocument projectValue;`
`370`		`- var result = AggregateLanguageTranslator.Translate(selector);`
	`372`	`+ var result = AggregateLanguageTranslator.Translate(selector, _translationOptions);`
`371`	`373`	`if (result.BsonType == BsonType.String)`
`372`	`374`	`{`
`373`	`375`	`// this means we got back a field expression prefixed with a $ sign.`