Support DBRef documents in Filters.not

JAVA-2877

Author: rozza

driver-core/src/main/com/mongodb/client/model/Filters.java

@@ -34,13 +34,16 @@
 import org.bson.conversions.Bson;
 
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.regex.Pattern;
 
 import static com.mongodb.assertions.Assertions.notNull;
 import static com.mongodb.client.model.BuildersHelper.encodeValue;
 import static java.util.Arrays.asList;
+import static java.util.Collections.unmodifiableSet;
 
 /**
  * A factory for query filters. A convenient way to use this class is to statically import all of its methods, which allows usage like:
@@ -1119,6 +1122,8 @@ public String toString() {
     }
 
     private static class NotFilter implements Bson {
+        private static final Set<String> DBREF_KEYS = unmodifiableSet(new HashSet<String>(asList("$ref", "$id")));
+        private static final Set<String> DBREF_KEYS_WITH_DB =  unmodifiableSet(new HashSet<String>(asList("$ref", "$id", "$db")));
         private final Bson filter;
 
         NotFilter(final Bson filter) {
@@ -1140,10 +1145,25 @@ public <TDocument> BsonDocument toBsonDocument(final Class<TDocument> documentCl
             }
         }
 
+        private boolean containsOperator(final BsonDocument value) {
+            Set<String> keys = value.keySet();
+            if (keys.equals(DBREF_KEYS) || keys.equals(DBREF_KEYS_WITH_DB)) {
+                return false;
+            }
+
+            for (String key : keys) {
+                if (key.startsWith("$")) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         private BsonDocument createFilter(final String fieldName, final BsonValue value) {
             if (fieldName.startsWith("$")) {
                 return new BsonDocument("$not", new BsonDocument(fieldName, value));
-            } else if (value.isDocument() || value.isRegularExpression()) {
+            } else if ((value.isDocument() && containsOperator(value.asDocument())) || value.isRegularExpression()) {
                 return new BsonDocument(fieldName, new BsonDocument("$not", value));
             }
             return new BsonDocument(fieldName, new BsonDocument("$not", new BsonDocument("$eq", value)));

driver-core/src/test/functional/com/mongodb/client/model/FiltersFunctionalSpecification.groovy

@@ -94,7 +94,31 @@ class FiltersFunctionalSpecification extends OperationFunctionalSpecification {
         find(not(regex('y', 'a.*'))) == [b, c]
 
         when:
-        find(not(and(eq('x', 1), eq('x', 1)))) == [b, c]
+        def dbref = Document.parse('{$ref: "1", $id: "1"}')
+        def dbrefDoc = new Document('_id', 4).append('dbref', dbref)
+        getCollectionHelper().insertDocuments(dbrefDoc)
+
+        then:
+        find(not(eq('dbref', dbref))) == [a, b, c]
+
+        when:
+        getCollectionHelper().deleteOne(dbrefDoc)
+        dbref.put('$db', '1')
+        dbrefDoc.put('dbref', dbref)
+        getCollectionHelper().insertDocuments(dbrefDoc)
+
+        then:
+        find(not(eq('dbref', dbref))) == [a, b, c]
+
+        when:
+        def subDoc = Document.parse('{x: 1, b: 1}')
+        getCollectionHelper().insertDocuments(new Document('subDoc', subDoc))
+
+        then:
+        find(not(eq('subDoc', subDoc))) == [a, b, c, dbrefDoc]
+
+        when:
+        find(not(and(eq('x', 1), eq('x', 1))))
 
         then:
         thrown MongoQueryException

driver-core/src/test/unit/com/mongodb/client/model/FiltersSpecification.groovy

@@ -70,7 +70,6 @@ import static com.mongodb.client.model.Filters.size
 import static com.mongodb.client.model.Filters.text
 import static com.mongodb.client.model.Filters.type
 import static com.mongodb.client.model.Filters.where
-import static java.util.Arrays.asList
 import static org.bson.BsonDocument.parse
 import static org.bson.codecs.configuration.CodecRegistries.fromProviders
 
@@ -106,7 +105,11 @@ class FiltersSpecification extends Specification {
         toBson(not(or(eq('x', 1), eq('x', 2)))) == parse('{$not: {$or: [{x: 1}, {x: 2}]}}')
         toBson(not(or(Filters.in('x', 1, 2), eq('x', 3)))) == parse('{$not: {$or: [{x: {$in: [1, 2]}}, {x: 3}]}}')
 
-        toBson(not(new BsonDocument('$in', new BsonArray(asList(new BsonInt32(1)))))) == parse('{$not: {$in: [1]}}')
+        toBson(not(parse('{$in: [1]}'))) == parse('{$not: {$in: [1]}}')
+
+        toBson(not(eq('x', parse('{a: 1, b: 1}')))) == parse('{x: {$not: {$eq: {"a": 1, "b": 1}}}}')
+        toBson(not(eq('x', parse('{$ref: "1", $id: "1"}')))) == parse('{x: {$not: {$eq: {"$ref": "1", "$id": "1"}}}}')
+        toBson(not(eq('x', parse('{$ref: "1", $id: "1", $db: "db"}')))) == parse('{x: {$not: {$eq: {"$ref": "1", "$id": "1", $db: "db"}}}}')
     }
 
     def 'should render $nor'() {