Add KeyFunction support to group in DBCollection

JAVA-1979

Author: rozza

driver/src/main/com/mongodb/GroupCommand.java

@@ -20,6 +20,8 @@
 import org.bson.BsonDocumentWrapper;
 import org.bson.BsonJavaScript;
 
+import static com.mongodb.assertions.Assertions.notNull;
+
 /**
  * This class groups the argument for a group operation and can build the underlying command object
  *
@@ -28,6 +30,7 @@
 public class GroupCommand {
     private final String collectionName;
     private final DBObject keys;
+    private final String keyf;
     private final DBObject condition;
     private final DBObject initial;
     private final String reduce;
@@ -45,12 +48,38 @@ public class GroupCommand {
      */
     public GroupCommand(final DBCollection collection, final DBObject keys, final DBObject condition,
                         final DBObject initial, final String reduce, final String finalize) {
+        notNull("collection", collection);
         this.collectionName = collection.getName();
         this.keys = keys;
         this.condition = condition;
         this.initial = initial;
         this.reduce = reduce;
         this.finalize = finalize;
+        this.keyf = null;
+    }
+
+    /**
+     * Creates a new group command.
+     *
+     * @param collection the collection from which to perform the group by operation.
+     * @param keyf       the function that creates a "key object" for use as the grouping key
+     * @param condition  optional - a filter to determine which documents in the collection to process.
+     * @param initial    the initial state of the aggregation result document.
+     * @param reduce     a JavaScript aggregation function that operates on the documents during the grouping operation.
+     * @param finalize   optional - a JavaScript function that runs each item in the result set before group returns the final value.
+     *
+     * @since 3.1
+     */
+    public GroupCommand(final DBCollection collection, final String keyf, final DBObject condition,
+                        final DBObject initial, final String reduce, final String finalize) {
+        notNull("collection", collection);
+        this.collectionName = collection.getName();
+        this.keyf = notNull("keyf", keyf);
+        this.condition = condition;
+        this.initial = initial;
+        this.reduce = reduce;
+        this.finalize = finalize;
+        this.keys = null;
     }
 
     /**
@@ -59,10 +88,18 @@ public GroupCommand(final DBCollection collection, final DBObject keys, final DB
      * @return a DBObject containing the group command as a MongoDB document
      */
     public DBObject toDBObject() {
-        DBObject args = new BasicDBObject("ns", collectionName).append("key", keys)
-                                                               .append("cond", condition)
+        DBObject args = new BasicDBObject("ns", collectionName).append("cond", condition)
                                                                .append("$reduce", reduce)
                                                                .append("initial", initial);
+
+        if (keys != null) {
+            args.put("key", keys);
+        }
+
+        if (keyf != null) {
+            args.put("$keyf", keyf);
+        }
+
         if (finalize != null) {
             args.put("finalize", finalize);
         }
@@ -86,6 +123,10 @@ GroupOperation<DBObject> toOperation(final MongoNamespace namespace, final DBObj
             operation.key(new BsonDocumentWrapper<DBObject>(keys, codec));
         }
 
+        if (keyf != null) {
+            operation.keyFunction(new BsonJavaScript(keyf));
+        }
+
         if (condition != null) {
             operation.filter(new BsonDocumentWrapper<DBObject>(condition, codec));
         }

driver/src/test/functional/com/mongodb/DBCollectionFunctionalSpecification.groovy

@@ -387,6 +387,24 @@ class DBCollectionFunctionalSpecification extends FunctionalSpecification {
         that result, contains(~['x': 'a', 'count': 3.0D], ~['x': 'b', 'count': 4.0D], ~['x': 'c', 'count': 1.0D]);
     }
 
+    def 'should group using a key function in a GroupCommand'() {
+        given:
+        insertDataForGroupTests()
+        GroupCommand command = new GroupCommand(collection,
+                'function(doc){ return {x: doc.x} }',
+                null,
+                ~['count': 0],
+                'function(o , p){ p.count++; }',
+                null);
+
+        when:
+        DBObject result = collection.group(command);
+
+        then:
+        result.size() == 3
+        that result, contains(~['x': 'a', 'count': 3.0D], ~['x': 'b', 'count': 4.0D], ~['x': 'c', 'count': 1.0D]);
+    }
+
     def 'should group and count only those documents that fulfull the given condition'() {
         given:
         insertDataForGroupTests()