CSHARP-2614: Fix logic for projection where one field name starts with another field name.

Author: DmitryLukyanov

src/MongoDB.Driver/Linq/Translators/FindProjectionTranslator.cs

@@ -89,7 +89,9 @@ private FindProjectionTranslator(DocumentExpression documentExpression, Paramete
 
         protected internal override Expression VisitField(FieldExpression node)
         {
-            if (!_fields.Any(x => x.FieldName == node.FieldName
+            var dottedFieldExpression = GetDottedFieldExpression(node);
+
+            if (!_fields.Any(x => x.FieldName == dottedFieldExpression.FieldName
                 && x.Serializer.ValueType == node.Serializer.ValueType))
             {
                 // we need to unwind this call...
@@ -100,7 +102,7 @@ protected internal override Expression VisitField(FieldExpression node)
                 _parameterExpression,
                 "GetValue",
                 new[] { node.Type },
-                Expression.Constant(node.FieldName),
+                Expression.Constant(dottedFieldExpression.FieldName),
                 Expression.Constant(node.Serializer.ValueType.GetDefaultValue(), typeof(object)));
         }
 
@@ -156,6 +158,30 @@ protected internal override Expression VisitDocument(DocumentExpression node)
             return base.VisitDocument(node);
         }
 
+        private FieldExpression GetDottedFieldExpression(FieldExpression node)
+        {
+            var fieldNames = new List<string> { node.FieldName };
+            var document = node.Document as FieldExpression;
+            while (document != null)
+            {
+                fieldNames.Add(document.FieldName);
+                document = document.Document as FieldExpression;
+            }
+
+            string dottedFieldName;
+            if (fieldNames.Count > 1)
+            {
+                fieldNames.Reverse();
+                dottedFieldName = string.Join(".", fieldNames);
+            }
+            else
+            {
+                dottedFieldName = fieldNames[0];
+            }
+
+            return new FieldExpression(null, dottedFieldName, node.Serializer, node.Original);
+        }
+
         private static BsonDocument GetProjectionDocument(IEnumerable<BsonSerializationInfo> used)
         {
             var includeId = false;
@@ -192,7 +218,12 @@ private static IReadOnlyList<IFieldExpression> GetUniqueFieldsByHierarchy(IEnume
                 var referenceGroup = referenceGroups.Dequeue();
                 if (!skippedFields.Contains(referenceGroup.Key))
                 {
-                    var hierarchicalReferenceGroups = referenceGroups.Where(x => x.Key.StartsWith(referenceGroup.Key));
+                    var hierarchicalReferenceGroups = referenceGroups
+                        .Where(x =>
+                        {
+                            return x.Key.Count(c => c == '.') != referenceGroup.Key.Count(c => c == '.') && // otherwise, fields are on the same nesting level
+                                   x.Key.StartsWith(referenceGroup.Key);
+                        });
                     uniqueFields.AddRange(referenceGroup);
                     skippedFields.AddRange(hierarchicalReferenceGroups.Select(x => x.Key));
                 }

tests/MongoDB.Driver.Tests/Linq/Translators/FindProjectionTranslatorTests.cs

@@ -92,6 +92,20 @@ public void Should_translate_a_single_top_level_field_with_an_operation()
             result.Value.Should().Be("jack");
         }
 
+        [Fact]
+        public void Should_translate_a_new_expression_where_one_field_starts_with_another_field()
+        {
+            var result = Project(p => new { p.C.E, p.C.E1 }, "{  C : { E : { F : 2, H : 3 }, E1 : { F : 4, H : 5 } } }");
+
+            result.Projection.Should().Be("{ \"C.E\" : 1, \"C.E1\" : 1, _id : 0 }");
+
+            result.Value.E.F.Should().Be(2);
+            result.Value.E.H.Should().Be(3);
+
+            result.Value.E1.F.Should().Be(4);
+            result.Value.E1.H.Should().Be(5);
+        }
+
         [Fact]
         public void Should_translate_a_new_expression_with_a_single_top_level_field()
         {
@@ -112,6 +126,17 @@ public void Should_translate_a_new_expression_with_a_single_top_level_computed_f
             result.Value.FullName.Should().Be("Jack Awesome");
         }
 
+        [Fact]
+        public void Should_translate_a_new_expression_with_top_level_fields_when_one_field_starts_with_another()
+        {
+            var result = Project(p => new { p.A, p.A1 }, "{ A : \"Jack\", A1 : \"Peter\" }");
+
+            result.Projection.Should().Be("{ A : 1, A1 : 1 _id: 0 }");
+
+            result.Value.A.Should().Be("Jack");
+            result.Value.A1.Should().Be("Peter");
+        }
+
         [Fact]
         public void Should_translate_when_a_top_level_field_is_repeated()
         {
@@ -144,7 +169,19 @@ public void Should_translate_with_a_single_computed_nested_field()
         }
 
         [Fact]
-        public void Should_translate_with_a_hierarchical_redundancy()
+        public void Should_translate_with_a_hierarchical_redundancy_and_a_non_top_level_projection()
+        {
+            var result = Project(p => new { p.C.E, F = p.C.E.F }, "{  C : { E : { F : 2, H : 3 } } }");
+
+            result.Projection.Should().Be("{ \"C.E\" : 1, _id : 0 }");
+
+            result.Value.E.H.Should().Be(3);
+            result.Value.F.Should().Be(2);
+            result.Value.E.F.Should().Be(2);
+        }
+
+        [Fact]
+        public void Should_translate_with_a_hierarchical_redundancy_and_a_top_level_projection()
         {
             var result = Project(p => new { p.C, F = p.C.E.F }, "{ C: { D: \"CEO\", E: { F: 2 } } }");
 
@@ -155,6 +192,18 @@ public void Should_translate_with_a_hierarchical_redundancy()
             result.Value.F.Should().Be(2);
         }
 
+        [Fact]
+        public void Should_translate_with_a_hierarchical_redundancy_and_when_one_field_starts_with_another()
+        {
+            var result = Project(p => new { p.C.E, F = p.C.E.E1.F }, "{  C : { E : { E1 : { F : 2, H : 3 } } } }");
+
+            result.Projection.Should().Be("{ \"C.E\" : 1, _id : 0 }");
+
+            result.Value.E.E1.H.Should().Be(3);
+            result.Value.E.E1.F.Should().Be(2);
+            result.Value.F.Should().Be(2);
+        }
+
         [Fact]
         public void Should_translate_a_single_top_level_array()
         {
@@ -259,6 +308,8 @@ private class Root
 
             public string A { get; set; }
 
+            public string A1 { get; set; }
+
             public string B { get; set; }
 
             public C C { get; set; }
@@ -271,6 +322,8 @@ public class C
             public string D { get; set; }
 
             public E E { get; set; }
+
+            public E E1 { get; set; }
         }
 
         public class E
@@ -280,6 +333,8 @@ public class E
             public int H { get; set; }
 
             public IEnumerable<string> I { get; set; }
+
+            public E E1 { get; set; }
         }
     }
 }