JAVA-2757: Drop index by keys when keys are provided

When the application drops an index using a method that takes the index
keys, rather than the name, the driver drops the index by those keys
rather than constructing a name from the keys and dropping it by that
name.

This allows the dropping of index by keys even when the index was
created with a name other than the default name.

Author: jyemin

driver-core/src/main/com/mongodb/operation/DropIndexOperation.java

@@ -35,16 +35,15 @@
 import static com.mongodb.assertions.Assertions.isTrueArgument;
 import static com.mongodb.assertions.Assertions.notNull;
 import static com.mongodb.internal.async.ErrorHandlingResultCallback.errorHandlingCallback;
+import static com.mongodb.internal.operation.WriteConcernHelper.appendWriteConcernToCommand;
 import static com.mongodb.operation.CommandOperationHelper.executeWrappedCommandProtocol;
 import static com.mongodb.operation.CommandOperationHelper.executeWrappedCommandProtocolAsync;
 import static com.mongodb.operation.CommandOperationHelper.isNamespaceError;
+import static com.mongodb.operation.CommandOperationHelper.writeConcernErrorTransformer;
 import static com.mongodb.operation.DocumentHelper.putIfNotZero;
-import static com.mongodb.internal.operation.IndexHelper.generateIndexName;
 import static com.mongodb.operation.OperationHelper.LOGGER;
 import static com.mongodb.operation.OperationHelper.releasingCallback;
 import static com.mongodb.operation.OperationHelper.withConnection;
-import static com.mongodb.internal.operation.WriteConcernHelper.appendWriteConcernToCommand;
-import static com.mongodb.operation.CommandOperationHelper.writeConcernErrorTransformer;
 
 /**
  * An operation that drops an index.
@@ -55,6 +54,7 @@
 public class DropIndexOperation implements AsyncWriteOperation<Void>, WriteOperation<Void> {
     private final MongoNamespace namespace;
     private final String indexName;
+    private final BsonDocument indexKeys;
     private final WriteConcern writeConcern;
     private long maxTimeMS;
 
@@ -93,20 +93,22 @@ public DropIndexOperation(final MongoNamespace namespace, final BsonDocument key
     public DropIndexOperation(final MongoNamespace namespace, final String indexName, final WriteConcern writeConcern) {
         this.namespace = notNull("namespace", namespace);
         this.indexName = notNull("indexName", indexName);
+        this.indexKeys = null;
         this.writeConcern = writeConcern;
     }
 
     /**
      * Construct a new instance.
      *
      * @param namespace    the database and collection namespace for the operation.
-     * @param keys         the keys of the index to be dropped
+     * @param indexKeys    the keys of the index to be dropped
      * @param writeConcern the write concern
      * @since 3.4
      */
-    public DropIndexOperation(final MongoNamespace namespace, final BsonDocument keys, final WriteConcern writeConcern) {
+    public DropIndexOperation(final MongoNamespace namespace, final BsonDocument indexKeys, final WriteConcern writeConcern) {
         this.namespace = notNull("namespace", namespace);
-        this.indexName = generateIndexName(notNull("keys", keys));
+        this.indexKeys = notNull("indexKeys", indexKeys);
+        this.indexName = null;
         this.writeConcern = writeConcern;
     }
 
@@ -190,8 +192,13 @@ public void onResult(final Void result, final Throwable t) {
     }
 
     private BsonDocument getCommand(final ConnectionDescription description) {
-        BsonDocument command = new BsonDocument("dropIndexes", new BsonString(namespace.getCollectionName()))
-                                               .append("index", new BsonString(indexName));
+        BsonDocument command = new BsonDocument("dropIndexes", new BsonString(namespace.getCollectionName()));
+        if (indexName != null) {
+            command.put("index", new BsonString(indexName));
+        } else {
+            command.put("index", indexKeys);
+        }
+
         putIfNotZero(command, "maxTimeMS", maxTimeMS);
         appendWriteConcernToCommand(writeConcern, command, description);
         return command;

driver-core/src/test/functional/com/mongodb/operation/DropIndexOperationSpecification.groovy

@@ -24,9 +24,11 @@ import com.mongodb.WriteConcern
 import org.bson.BsonDocument
 import org.bson.BsonInt32
 import org.bson.BsonInt64
+import org.bson.BsonString
 import org.bson.Document
 import org.bson.codecs.DocumentCodec
 import spock.lang.IgnoreIf
+import spock.lang.Unroll
 
 import static com.mongodb.ClusterFixture.disableMaxTimeFailPoint
 import static com.mongodb.ClusterFixture.enableMaxTimeFailPoint
@@ -79,9 +81,9 @@ class DropIndexOperationSpecification extends OperationFunctionalSpecification {
         async << [true, false]
     }
 
+    @Unroll
     def 'should drop existing index by keys'() {
         given:
-        def keys = new BsonDocument('theField', new BsonInt32(1))
         collectionHelper.createIndex(keys)
 
         when:
@@ -93,7 +95,14 @@ class DropIndexOperationSpecification extends OperationFunctionalSpecification {
         indexes[0].name == '_id_'
 
         where:
-        async << [true, false]
+        [keys, async] << [
+                [new BsonDocument('theField', new BsonInt32(1)),
+                 new BsonDocument('theField', new BsonInt32(1)).append('theSecondField', new BsonInt32(-1)),
+                 new BsonDocument('theField', new BsonString('2d')),
+                 new BsonDocument('theField', new BsonString('hashed')),
+                ],
+                [true, false]
+        ].combinations()
     }
 
     @IgnoreIf({ isSharded() })

driver-legacy/src/main/com/mongodb/DBCollection.java

@@ -2199,7 +2199,11 @@ public ReadOperation<BatchCursor<DBObject>> asReadOperation() {
      * @mongodb.driver.manual core/indexes/ Indexes
      */
     public void dropIndex(final DBObject index) {
-        dropIndex(getIndexNameFromIndexFields(index));
+        try {
+            executor.execute(new DropIndexOperation(getNamespace(), wrap(index), getWriteConcern()), getReadConcern());
+        } catch (MongoWriteConcernException e) {
+            throw createWriteConcernException(e);
+        }
     }
 
     /**
@@ -2473,31 +2477,6 @@ private CreateIndexesOperation createIndexOperation(final DBObject key, final DB
         return new CreateIndexesOperation(getNamespace(), singletonList(request), writeConcern);
     }
 
-    private String getIndexNameFromIndexFields(final DBObject index) {
-        StringBuilder indexName = new StringBuilder();
-        for (final String keyNames : index.keySet()) {
-            if (indexName.length() != 0) {
-                indexName.append('_');
-            }
-            indexName.append(keyNames).append('_');
-            Object keyType = index.get(keyNames);
-            if (keyType instanceof Integer) {
-                List<Integer> validIndexTypes = asList(1, -1);
-                if (!validIndexTypes.contains(keyType)) {
-                    throw new UnsupportedOperationException("Unsupported index type: " + keyType);
-                }
-                indexName.append(((Integer) keyType));
-            } else if (keyType instanceof String) {
-                List<String> validIndexTypes = asList("2d", "2dsphere", "text", "geoHaystack", "hashed");
-                if (!validIndexTypes.contains(keyType)) {
-                    throw new UnsupportedOperationException("Unsupported index type: " + keyType);
-                }
-                indexName.append(((String) keyType).replace(' ', '_'));
-            }
-        }
-        return indexName.toString();
-    }
-
     Codec<DBObject> getObjectCodec() {
         return objectCodec;
     }

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

@@ -210,7 +210,7 @@ class DBCollectionFunctionalSpecification extends FunctionalSpecification {
 
         then:
         def exception = thrown(MongoCommandException)
-        exception.getErrorMessage().contains('index not found')
+        exception.getErrorMessage().contains('can\'t find index')
     }
 
     def 'should drop nested index'() {
@@ -799,6 +799,17 @@ class DBCollectionFunctionalSpecification extends FunctionalSpecification {
         result == document
     }
 
+    def 'should drop compound index by key'() {
+        given:
+        def indexKeys = new BasicDBObject('x', 1).append('y', -1)
+        collection.createIndex(indexKeys)
+
+        when:
+        collection.dropIndex(indexKeys)
+
+        then:
+        collection.getIndexInfo().size() == 1
+    }
 
     def caseInsensitive = Collation.builder().locale('en').collationStrength(CollationStrength.SECONDARY).build()
 }