CSHARP-1432: added support for $all in predicates.

Author: craiggwilson

Docs/reference/content/reference/driver/expressions.md

@@ -114,6 +114,21 @@ Find(p => localAges.Contains(p.Age));
 { Age: { $in: [10, 20, 30] } }
 ```
 
+```csharp
+int[] localNames = new [] { "Fluffy", "Scruffy" };
+Find(p => p.Pets.Any(i => localNames.Contains(i.Name));
+```
+```json
+{ "Pets.Name": { $in: ["Fluffy", "Scruffy"] } }
+```
+
+```csharp
+int[] localNumbers = new [] { 30, 40 };
+Find(p => localNumbers.Any(i => p.FavoriteNumbers.Contains(i));
+```
+```json
+{ FavoriteNumbers: { $in: [30, 40] } } 
+
 #### $nin
 
 ```csharp
@@ -247,14 +262,18 @@ See the [MongoDB documentation]({{< docsref "reference/operator/query/#geospatia
 // no example yet
 ```
 
-### Geospatial
+### Array
 
 See the [MongoDB documentation]({{< docsref "reference/operator/query/#array" >}}) for more information on each operator.
 
 #### $all
 
 ```csharp
-// no example yet
+var local = new [] { 10, 20 };
+Find(x => local.All(i => FavoriteNumbers.Contains(i));
+```
+```json
+{ FavoriteNumbers: { $all: [10, 20] } }
 ```
 
 #### $elemMatch
@@ -270,7 +289,7 @@ Find(x => x.Pets.Any(p => p.Name == "Fluffy" && p.Age > 21);
 Find(x => x.FavoriteNumbers.Any(n => n < 42 && n > 21));
 ```
 ```json
-{ FavoriteNumbers: { $elemMatch: { { $lt: 42, $gt: 21 } } } }
+{ FavoriteNumbers: { $elemMatch: { $lt: 42, $gt: 21 } } }
 ```
 
 {{% note %}}Depending on the complexity and the operators involved in the Any method call, the driver might eliminate the $elemMatch completely. For instance,

src/MongoDB.Driver.Tests/Linq/Translators/PredicateTranslatorTests.cs

@@ -31,6 +31,28 @@ namespace MongoDB.Driver.Tests.Linq.Translators
     [TestFixture]
     public class PredicateTranslatorTests : IntegrationTestBase
     {
+        [Test]
+        public void All()
+        {
+            var local = new[] { "itchy" };
+
+            Assert(
+                x => local.All(i => x.C.E.I.Contains(i)),
+                1,
+                "{'C.E.I': { $all: [ 'itchy' ] } }");
+        }
+
+        [Test]
+        public void All_with_a_not()
+        {
+            var local = new[] { "itchy" };
+
+            Assert(
+                x => !local.All(i => x.C.E.I.Contains(i)),
+                1,
+                "{'C.E.I': { $not: { $all: [ 'itchy' ] } } }");
+        }
+
         [Test]
         public void Any_without_a_predicate()
         {
@@ -122,7 +144,7 @@ public void Any_with_a_predicate_on_scalars()
         }
 
         [Test]
-        public void Any_with_local_contains()
+        public void Any_with_local_contains_on_an_embedded_document()
         {
             var local = new List<string> { "Delilah", "Dolphin" };
 
@@ -132,6 +154,17 @@ public void Any_with_local_contains()
                 "{\"G.D\": { $in: [\"Delilah\", \"Dolphin\" ] } }");
         }
 
+        [Test]
+        public void Any_with_local_contains_on_a_scalar_array()
+        {
+            var local = new List<string> { "itchy" };
+
+            Assert(
+                x => local.Any(i => x.C.E.I.Contains(i)),
+                1,
+                "{\"C.E.I\": { $in: [\"itchy\" ] } }");
+        }
+
         [Test]
         public void LocalIListContains()
         {

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

@@ -750,11 +750,14 @@ private FilterDefinition<BsonDocument> TranslateOr(BinaryExpression binaryExpres
 
         private FilterDefinition<BsonDocument> TranslatePipeline(PipelineExpression node)
         {
+            if (node.ResultOperator is AllResultOperator)
+            {
+                return TranslatePipelineAll(node);
+            }
             if (node.ResultOperator is AnyResultOperator)
             {
                 return TranslatePipelineAny(node);
             }
-
             if (node.ResultOperator is ContainsResultOperator)
             {
                 return TranslatePipelineContains(node);
@@ -763,6 +766,48 @@ private FilterDefinition<BsonDocument> TranslatePipeline(PipelineExpression node
             return null;
         }
 
+        private FilterDefinition<BsonDocument> TranslatePipelineAll(PipelineExpression node)
+        {
+            var whereExpression = node.Source as WhereExpression;
+            if (whereExpression == null)
+            {
+                return null;
+            }
+
+            var constant = whereExpression.Source as ConstantExpression;
+            if (constant == null)
+            {
+                return null;
+            }
+
+            var embeddedPipeline = whereExpression.Predicate as PipelineExpression;
+            if (!(embeddedPipeline?.ResultOperator is ContainsResultOperator))
+            {
+                return null;
+            }
+
+            var fieldExpression = embeddedPipeline.Source as IFieldExpression;
+            if (fieldExpression == null)
+            {
+                return null;
+            }
+
+            var arraySerializer = fieldExpression.Serializer as IBsonArraySerializer;
+            if (arraySerializer == null)
+            {
+                return null;
+            }
+
+            BsonSerializationInfo itemSerializationInfo;
+            if (!arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo))
+            {
+                return null;
+            }
+
+            var serializedValues = itemSerializationInfo.SerializeValues((IEnumerable)constant.Value);
+            return __builder.All(fieldExpression.FieldName, serializedValues);
+        }
+
         private FilterDefinition<BsonDocument> TranslatePipelineAny(PipelineExpression node)
         {
             var fieldExpression = node.Source as IFieldExpression;
@@ -773,7 +818,6 @@ private FilterDefinition<BsonDocument> TranslatePipelineAny(PipelineExpression n
                         __builder.Not(__builder.Size(fieldExpression.FieldName, 0)));
             }
 
-
             var whereExpression = node.Source as WhereExpression;
             if (whereExpression == null)
             {
@@ -783,6 +827,10 @@ private FilterDefinition<BsonDocument> TranslatePipelineAny(PipelineExpression n
             fieldExpression = whereExpression.Source as IFieldExpression;
             if (fieldExpression == null)
             {
+                if (whereExpression.Source is ConstantExpression)
+                {
+                    return TranslatePipelineAnyScalar(node);
+                }
                 return null;
             }
 
@@ -807,6 +855,48 @@ private FilterDefinition<BsonDocument> TranslatePipelineAny(PipelineExpression n
             return filter;
         }
 
+        private FilterDefinition<BsonDocument> TranslatePipelineAnyScalar(PipelineExpression node)
+        {
+            var whereExpression = node.Source as WhereExpression;
+            if (whereExpression == null)
+            {
+                return null;
+            }
+
+            var constant = whereExpression.Source as ConstantExpression;
+            if (constant == null)
+            {
+                return null;
+            }
+
+            var embeddedPipeline = whereExpression.Predicate as PipelineExpression;
+            if (!(embeddedPipeline?.ResultOperator is ContainsResultOperator))
+            {
+                return null;
+            }
+
+            var fieldExpression = embeddedPipeline.Source as IFieldExpression;
+            if (fieldExpression == null)
+            {
+                return null;
+            }
+
+            var arraySerializer = fieldExpression.Serializer as IBsonArraySerializer;
+            if (arraySerializer == null)
+            {
+                return null;
+            }
+
+            BsonSerializationInfo itemSerializationInfo;
+            if (!arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo))
+            {
+                return null;
+            }
+
+            var serializedValues = itemSerializationInfo.SerializeValues((IEnumerable)constant.Value);
+            return __builder.In(fieldExpression.FieldName, serializedValues);
+        }
+
         private FilterDefinition<BsonDocument> TranslatePipelineContains(PipelineExpression node)
         {
             var value = ((ContainsResultOperator)node.ResultOperator).Value;