GODRIVER-2701 (Master) Implement a variant of DropIndex that gets keys rather than name (#1707)

Author: timothy-kim-mongo

internal/integration/index_view_test.go

@@ -581,6 +581,88 @@ func TestIndexView(t *testing.T) {
 		}
 		assert.Nil(mt, cursor.Err(), "cursor error: %v", cursor.Err())
 	})
+	mt.Run("drop with key", func(mt *mtest.T) {
+		tests := []struct {
+			name   string
+			models []mongo.IndexModel
+			index  any
+			want   string
+		}{
+			{
+				name: "custom index name and unique indexes",
+				models: []mongo.IndexModel{
+					{
+						Keys:    bson.D{{"username", int32(1)}},
+						Options: options.Index().SetUnique(true).SetName("myidx"),
+					},
+				},
+				index: bson.D{{"username", int32(1)}},
+				want:  "myidx",
+			},
+			{
+				name: "normal generated index name",
+				models: []mongo.IndexModel{
+					{
+						Keys: bson.D{{"foo", int32(-1)}},
+					},
+				},
+				index: bson.D{{"foo", int32(-1)}},
+				want:  "foo_-1",
+			},
+			{
+				name: "compound index",
+				models: []mongo.IndexModel{
+					{
+						Keys: bson.D{{"foo", int32(1)}, {"bar", int32(1)}},
+					},
+				},
+				index: bson.D{{"foo", int32(1)}, {"bar", int32(1)}},
+				want:  "foo_1_bar_1",
+			},
+			{
+				name: "text index",
+				models: []mongo.IndexModel{
+					{
+						Keys: bson.D{{"plot1", "text"}, {"plot2", "text"}},
+					},
+				},
+				// Key is automatically set to Full Text Search for any text index
+				index: bson.D{{"_fts", "text"}, {"_ftsx", int32(1)}},
+				want:  "plot1_text_plot2_text",
+			},
+		}
+
+		for _, test := range tests {
+			mt.Run(test.name, func(mt *mtest.T) {
+				iv := mt.Coll.Indexes()
+				indexNames, err := iv.CreateMany(context.Background(), test.models)
+
+				s, _ := test.index.(bson.D)
+				for _, name := range indexNames {
+					verifyIndexExists(mt, iv, index{
+						Key:  s,
+						Name: name,
+					})
+				}
+
+				assert.NoError(mt, err)
+				assert.Equal(mt, len(test.models), len(indexNames), "expected %v index names, got %v", len(test.models), len(indexNames))
+
+				err = iv.DropWithKey(context.Background(), test.index)
+				assert.Nil(mt, err, "DropOne error: %v", err)
+
+				cursor, err := iv.List(context.Background())
+				assert.Nil(mt, err, "List error: %v", err)
+				for cursor.Next(context.Background()) {
+					var idx index
+					err = cursor.Decode(&idx)
+					assert.Nil(mt, err, "Decode error: %v (document %v)", err, cursor.Current)
+					assert.NotEqual(mt, test.want, idx.Name, "found index %v after dropping", test.want)
+				}
+				assert.Nil(mt, cursor.Err(), "cursor error: %v", cursor.Err())
+			})
+		}
+	})
 	mt.Run("drop all", func(mt *mtest.T) {
 		iv := mt.Coll.Indexes()
 		names, err := iv.CreateMany(context.Background(), []mongo.IndexModel{

mongo/index_view.go

@@ -383,7 +383,7 @@ func (iv IndexView) createOptionsDoc(opts options.Lister[options.IndexOptions])
 	return optsDoc, nil
 }
 
-func (iv IndexView) drop(ctx context.Context, name string, _ ...options.Lister[options.DropIndexesOptions]) error {
+func (iv IndexView) drop(ctx context.Context, index any, _ ...options.Lister[options.DropIndexesOptions]) error {
 	if ctx == nil {
 		ctx = context.Background()
 	}
@@ -409,8 +409,7 @@ func (iv IndexView) drop(ctx context.Context, name string, _ ...options.Lister[o
 
 	selector := makePinnedSelector(sess, iv.coll.writeSelector)
 
-	op := operation.NewDropIndexes(name).
-		Session(sess).WriteConcern(wc).CommandMonitor(iv.coll.client.monitor).
+	op := operation.NewDropIndexes(index).Session(sess).WriteConcern(wc).CommandMonitor(iv.coll.client.monitor).
 		ServerSelector(selector).ClusterClock(iv.coll.client.clock).
 		Database(iv.coll.db.name).Collection(iv.coll.name).
 		Deployment(iv.coll.client.deployment).ServerAPI(iv.coll.client.serverAPI).
@@ -448,8 +447,19 @@ func (iv IndexView) DropOne(
 	return iv.drop(ctx, name, opts...)
 }
 
-// DropAll executes a dropIndexes operation to drop all indexes on the
-// collection.
+// DropWithKey drops a collection index by key using the dropIndexes operation.
+//
+// This function is useful to drop an index using its key specification instead of its name.
+func (iv IndexView) DropWithKey(ctx context.Context, keySpecDocument interface{}, opts ...options.Lister[options.DropIndexesOptions]) error {
+	doc, err := marshal(keySpecDocument, iv.coll.bsonOpts, iv.coll.registry)
+	if err != nil {
+		return err
+	}
+
+	return iv.drop(ctx, doc, opts...)
+}
+
+// DropAll executes a dropIndexes operation to drop all indexes on the collection.
 //
 // The opts parameter can be used to specify options for this operation (see the
 // options.DropIndexesOptions documentation).

x/mongo/driver/operation/drop_indexes.go

@@ -23,7 +23,7 @@ import (
 
 // DropIndexes performs an dropIndexes operation.
 type DropIndexes struct {
-	index        *string
+	index        any
 	session      *session.Client
 	clock        *session.ClusterClock
 	collection   string
@@ -64,9 +64,9 @@ func buildDropIndexesResult(response bsoncore.Document) (DropIndexesResult, erro
 }
 
 // NewDropIndexes constructs and returns a new DropIndexes.
-func NewDropIndexes(index string) *DropIndexes {
+func NewDropIndexes(index any) *DropIndexes {
 	return &DropIndexes{
-		index: &index,
+		index: index,
 	}
 }
 
@@ -105,19 +105,26 @@ func (di *DropIndexes) Execute(ctx context.Context) error {
 
 func (di *DropIndexes) command(dst []byte, _ description.SelectedServer) ([]byte, error) {
 	dst = bsoncore.AppendStringElement(dst, "dropIndexes", di.collection)
-	if di.index != nil {
-		dst = bsoncore.AppendStringElement(dst, "index", *di.index)
+
+	switch di.index.(type) {
+	case string:
+		dst = bsoncore.AppendStringElement(dst, "index", di.index.(string))
+	case bsoncore.Document:
+		if di.index != nil {
+			dst = bsoncore.AppendDocumentElement(dst, "index", di.index.(bsoncore.Document))
+		}
 	}
+
 	return dst, nil
 }
 
 // Index specifies the name of the index to drop. If '*' is specified, all indexes will be dropped.
-func (di *DropIndexes) Index(index string) *DropIndexes {
+func (di *DropIndexes) Index(index any) *DropIndexes {
 	if di == nil {
 		di = new(DropIndexes)
 	}
 
-	di.index = &index
+	di.index = index
 	return di
 }