Merge remote-tracking branch 'refs/remotes/mongodb/master' into force_bsonclassmaps

Author: simsateo

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

@@ -29,6 +29,8 @@ class Person
 	public HashSet<string> FavoriteNames { get; set; }
 
 	public DateTime CreatedAtUtc { get; set; }
+
+	public int PermissionFlags { get; set; }
 }
 
 class Pet
@@ -139,6 +141,42 @@ Find(p => !localAges.Contains(p.Age));
 { Age: { $nin: [10, 20, 30] } }
 ```
 
+#### $bitsAllClear
+
+```csharp
+Find(p => (p.PermissionFlags & 7) == 0);
+```
+```json
+{ PermissionFlags: { $bitsAllClear: 7 } }
+```
+
+#### $bitsAllSet
+
+```csharp
+Find(p => (p.PermissionFlags & 7) == 7);
+```
+```json
+{ PermissionFlags: { $bitsAllSet: 7 } }
+```
+
+#### $bitsAnyClear
+
+```csharp
+Find(p => (p.PermissionFlags & 7) != 7);
+```
+```json
+{ PermissionFlags: { $bitsAnyClear: 7 } }
+```
+
+#### $bitsAnySet
+
+```csharp
+Find(p => (p.PermissionFlags & 7) != 0);
+```
+```json
+{ PermissionFlags: { $bitsAnySet: 7 } }
+```
+
 ### Logical
 
 See the [MongoDB documentation]({{< docsref "reference/operator/query/#logical" >}}) for more information on each operator.

src/MongoDB.Driver.Legacy.Tests/Operations/CurrentOpUsingFindOperationTests.cs

@@ -72,7 +72,7 @@ public void CreateOperation_should_return_expected_result()
         }
 
         [Test]
-        [RequiresServer(VersionLessThan = "3.0.0")]
+        [RequiresServer(ClusterTypes = ClusterTypes.StandaloneOrReplicaSet, StorageEngines = "mmapv1")]
         public void Execute_should_return_expected_result()
         {
             var subject = new CurrentOpUsingFindOperation(_adminDatabaseNamespace, _messageEncoderSettings);

src/MongoDB.Driver.Tests/FilterDefinitionBuilderTests.cs

@@ -127,6 +127,70 @@ public void And_with_a_nested_and_and_clashing_keys_using_ampersand()
             Assert(filter, "{$and: [{a: 1}, {a: 2}, {c: 3}]}");
         }
 
+        [Test]
+        public void BitsAllClear()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAllClear("a", 43), "{a: {$bitsAllClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAllClear_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAllClear(x => x.Age, 43), "{age: {$bitsAllClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAllSet()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAllSet("a", 43), "{a: {$bitsAllSet: 43}}");
+        }
+
+        [Test]
+        public void BitsAllSet_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAllSet(x => x.Age, 43), "{age: {$bitsAllSet: 43}}");
+        }
+
+        [Test]
+        public void BitsAnyClear()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAnyClear("a", 43), "{a: {$bitsAnyClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAnyClear_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAnyClear(x => x.Age, 43), "{age: {$bitsAnyClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAnySet()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAnySet("a", 43), "{a: {$bitsAnySet: 43}}");
+        }
+
+        [Test]
+        public void BitsAnySet_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAnySet(x => x.Age, 43), "{age: {$bitsAnySet: 43}}");
+        }
+
         [Test]
         public void ElemMatch()
         {

src/MongoDB.Driver.Tests/Linq/MongoQueryableTests.cs

@@ -123,6 +123,14 @@ public void Count_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public void Count_with_no_matches()
+        {
+            var result = CreateQuery().Count(x => x.C.E.F == 13151235);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public async Task CountAsync()
         {
@@ -139,6 +147,14 @@ public async Task CountAsync_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public async Task CountAsync_with_no_matches()
+        {
+            var result = await CreateQuery().CountAsync(x => x.C.E.F == 123412523);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         [RequiresServer(MinimumVersion = "2.6.0")]
         public void Distinct_followed_by_where()
@@ -364,6 +380,14 @@ public void LongCount_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public void LongCount_with_no_results()
+        {
+            var result = CreateQuery().LongCount(x => x.C.E.F == 123452135);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public async Task LongCountAsync()
         {
@@ -380,6 +404,14 @@ public async Task LongCountAsync_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public async Task LongCountAsync_with_no_results()
+        {
+            var result = await CreateQuery().LongCountAsync(x => x.C.E.F == 12351235);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public void Max()
         {
@@ -1039,6 +1071,14 @@ public void Sum_with_selector()
             result.Should().Be(122);
         }
 
+        [Test]
+        public void Sum_with_no_results()
+        {
+            var result = CreateQuery().Where(x => x.C.E.F == 12341235).Sum(x => x.C.E.F);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public async Task SumAsync()
         {
@@ -1055,6 +1095,14 @@ public async Task SumAsync_with_selector()
             result.Should().Be(122);
         }
 
+        [Test]
+        public async Task SumAsync_with_no_results()
+        {
+            var result = await CreateQuery().Where(x => x.C.E.F == 21341235).SumAsync(x => x.C.E.F);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public void Take()
         {

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

@@ -165,6 +165,56 @@ public void Any_with_local_contains_on_a_scalar_array()
                 "{\"C.E.I\": { $in: [\"itchy\" ] } }");
         }
 
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAllClear_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 20) == 0,
+                1,
+                "{'C.E.F': { $bitsAllClear: 20 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAllSet_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 7) == 7,
+                1,
+                "{'C.E.F': { $bitsAllSet: 7 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAllSet_with_HasFlag()
+        {
+            Assert(
+                x => x.Q.HasFlag(Q.One),
+                1,
+                "{Q: { $bitsAllSet: 1 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAnyClear_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 7) != 7,
+                1,
+                "{'C.E.F': { $bitsAnyClear: 7 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAnySet_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 20) != 0,
+                1,
+                "{'C.E.F': { $bitsAnySet: 20 } }");
+        }
+
         [Test]
         public void LocalIListContains()
         {

src/MongoDB.Driver/FilterDefinitionBuilder.cs

@@ -290,6 +290,94 @@ public FilterDefinition<TDocument> AnyNin<TItem>(Expression<Func<TDocument, IEnu
             return AnyNin(new ExpressionFieldDefinition<TDocument>(field), values);
         }
 
+        /// <summary>
+        /// Creates a bits all clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAllClear(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAllClear", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAllClear(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAllClear(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all set filter.</returns>
+        public FilterDefinition<TDocument> BitsAllSet(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAllSet", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all set filter.</returns>
+        public FilterDefinition<TDocument> BitsAllSet(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAllSet(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAnyClear(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAnyClear", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAnyClear(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAnyClear(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any set filter.</returns>
+        public FilterDefinition<TDocument> BitsAnySet(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAnySet", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any set filter.</returns>
+        public FilterDefinition<TDocument> BitsAnySet(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAnySet(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
         /// <summary>
         /// Creates an element match filter for an array field.
         /// </summary>

src/MongoDB.Driver/Linq/Expressions/ISerializationExpression.cs

@@ -13,11 +13,13 @@
 * limitations under the License.
 */
 
+using System;
 using System.Collections;
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
+using MongoDB.Driver.Support;
 
 namespace MongoDB.Driver.Linq.Expressions
 {
@@ -44,6 +46,8 @@ public static BsonValue SerializeValue(this ISerializationExpression field, obje
         {
             Ensure.IsNotNull(field, nameof(field));
 
+            value = ConvertEnumIfNecessary(field.Serializer.ValueType, value);
+
             var tempDocument = new BsonDocument();
             using (var bsonWriter = new BsonDocumentWriter(tempDocument))
             {
@@ -67,7 +71,7 @@ public static BsonArray SerializeValues(this ISerializationExpression field, IEn
                 bsonWriter.WriteStartArray();
                 foreach (var value in values)
                 {
-                    field.Serializer.Serialize(context, value);
+                    field.Serializer.Serialize(context, ConvertEnumIfNecessary(field.Serializer.ValueType, value));
                 }
                 bsonWriter.WriteEndArray();
                 bsonWriter.WriteEndDocument();
@@ -89,5 +93,23 @@ private static string CombineFieldNames(string prefix, string suffix)
 
             return prefix + "." + suffix;
         }
+
+        private static object ConvertEnumIfNecessary(Type valueType, object value)
+        {
+            if (valueType.IsEnum || valueType.IsNullableEnum())
+            {
+                if (value != null)
+                {
+                    if (valueType.IsNullableEnum())
+                    {
+                        valueType = valueType.GetNullableUnderlyingType();
+                    }
+
+                    value = Enum.ToObject(valueType, value);
+                }
+            }
+
+            return value;
+        }
     }
 }

src/MongoDB.Driver/Linq/Expressions/ResultOperators/CountResultOperator.cs

@@ -40,12 +40,12 @@ public override Type Type
 
         public LambdaExpression CreateAggregator(Type sourceType)
         {
-            return ResultTransformerHelper.CreateAggregator("Single", sourceType);
+            return ResultTransformerHelper.CreateAggregator("SingleOrDefault", sourceType);
         }
 
         public LambdaExpression CreateAsyncAggregator(Type sourceType)
         {
-            return ResultTransformerHelper.CreateAsyncAggregator("SingleAsync", sourceType);
+            return ResultTransformerHelper.CreateAsyncAggregator("SingleOrDefaultAsync", sourceType);
         }
     }
 }

src/MongoDB.Driver/Linq/Expressions/ResultOperators/SumResultOperator.cs

@@ -40,12 +40,12 @@ public override Type Type
 
         public LambdaExpression CreateAggregator(Type sourceType)
         {
-            return ResultTransformerHelper.CreateAggregator("Single", sourceType);
+            return ResultTransformerHelper.CreateAggregator("SingleOrDefault", sourceType);
         }
 
         public LambdaExpression CreateAsyncAggregator(Type sourceType)
         {
-            return ResultTransformerHelper.CreateAsyncAggregator("SingleAsync", sourceType);
+            return ResultTransformerHelper.CreateAsyncAggregator("SingleOrDefaultAsync", sourceType);
         }
     }
 }

src/MongoDB.Driver/Linq/MongoQueryProviderImpl.cs

@@ -79,7 +79,14 @@ public object Execute(Expression expression)
                 Translate(expression));
 
             var lambda = Expression.Lambda(executionPlan);
-            return lambda.Compile().DynamicInvoke(null);
+            try
+            {
+                return lambda.Compile().DynamicInvoke(null);
+            }
+            catch (TargetInvocationException tie)
+            {
+                throw tie.InnerException;
+            }
         }
 
         public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken = default(CancellationToken))

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

@@ -259,6 +259,48 @@ private FilterDefinition<BsonDocument> TranslateArrayLength(Expression variableN
             return null;
         }
 
+        private FilterDefinition<BsonDocument> TranslateBitwiseComparison(Expression variableExpression, ExpressionType operatorType, ConstantExpression constantExpression)
+        {
+            var binaryExpression = variableExpression as BinaryExpression;
+            if (binaryExpression == null ||
+                binaryExpression.NodeType != ExpressionType.And ||
+                binaryExpression.Right.NodeType != ExpressionType.Constant ||
+                (operatorType != ExpressionType.Equal && operatorType != ExpressionType.NotEqual))
+            {
+                return null;
+            }
+
+            var field = GetFieldExpression(binaryExpression.Left);
+
+            var value = field.SerializeValue(((ConstantExpression)binaryExpression.Right).Value).ToInt64();
+            var comparison = Convert.ToInt64(constantExpression.Value);
+
+            if (value == comparison)
+            {
+                if (operatorType == ExpressionType.Equal)
+                {
+                    return __builder.BitsAllSet(field.FieldName, value);
+                }
+                else
+                {
+                    return __builder.BitsAnyClear(field.FieldName, value);
+                }
+            }
+            else if (comparison == 0)
+            {
+                if (operatorType == ExpressionType.Equal)
+                {
+                    return __builder.BitsAllClear(field.FieldName, value);
+                }
+                else
+                {
+                    return __builder.BitsAnySet(field.FieldName, value);
+                }
+            }
+
+            return null;
+        }
+
         private FilterDefinition<BsonDocument> TranslateBoolean(bool value)
         {
             if (value)
@@ -347,6 +389,12 @@ private FilterDefinition<BsonDocument> TranslateComparison(BinaryExpression bina
                 return query;
             }
 
+            query = TranslateBitwiseComparison(variableExpression, operatorType, constantExpression);
+            if (query != null)
+            {
+                return query;
+            }
+
             return TranslateComparison(variableExpression, operatorType, constantExpression);
         }
 
@@ -389,20 +437,6 @@ private FilterDefinition<BsonDocument> TranslateComparison(Expression variableEx
             }
 
             var fieldExpression = GetFieldExpression(variableExpression);
-            var valueType = fieldExpression.Serializer.ValueType;
-            if (valueType.IsEnum || valueType.IsNullableEnum())
-            {
-                if (!valueType.IsEnum && value != null)
-                {
-                    valueType = valueType.GetNullableUnderlyingType();
-                }
-
-                if (value != null)
-                {
-                    value = Enum.ToObject(valueType, value);
-                }
-            }
-
             var serializedValue = fieldExpression.SerializeValue(value);
             switch (operatorType)
             {
@@ -576,6 +610,19 @@ private FilterDefinition<BsonDocument> TranslateEquals(MethodCallExpression meth
             return null;
         }
 
+        private FilterDefinition<BsonDocument> TranslateHasFlag(MethodCallExpression methodCallExpression)
+        {
+            if (methodCallExpression.Object == null)
+            {
+                return null;
+            }
+
+            var field = GetFieldExpression(methodCallExpression.Object);
+            var value = field.SerializeValue(((ConstantExpression)methodCallExpression.Arguments[0]).Value).ToInt64();
+
+            return __builder.BitsAllSet(field.FieldName, value);
+        }
+
         private FilterDefinition<BsonDocument> TranslateIn(MethodCallExpression methodCallExpression)
         {
             var methodDeclaringType = methodCallExpression.Method.DeclaringType;
@@ -683,6 +730,7 @@ private FilterDefinition<BsonDocument> TranslateMethodCall(MethodCallExpression
                 case "ContainsKey": return TranslateContainsKey(methodCallExpression);
                 case "EndsWith": return TranslateStringQuery(methodCallExpression);
                 case "Equals": return TranslateEquals(methodCallExpression);
+                case "HasFlag": return TranslateHasFlag(methodCallExpression);
                 case "In": return TranslateIn(methodCallExpression);
                 case "IsMatch": return TranslateIsMatch(methodCallExpression);
                 case "IsNullOrEmpty": return TranslateIsNullOrEmpty(methodCallExpression);