RUST-957 Implement sync index management API

Author: Nathan Blinn

src/coll/mod.rs

@@ -355,7 +355,7 @@ impl<T> Collection<T> {
         let response = self
             .create_indexes_common(vec![index], options, session)
             .await?;
-        Ok(response.into())
+        Ok(response.into_create_index_result())
     }
 
     /// Creates the given index on this collection.
@@ -367,7 +367,7 @@ impl<T> Collection<T> {
         self.create_index_common(index, options, None).await
     }
 
-    /// Convenience method for creating a single index on an explicit session.
+    /// Creates the given index on this collection using the provided `ClientSession`.
     pub async fn create_index_with_session(
         &self,
         index: IndexModel,
@@ -386,7 +386,7 @@ impl<T> Collection<T> {
         self.create_indexes_common(indexes, options, None).await
     }
 
-    /// Create several indexes on an explicit session.
+    /// Creates the given indexes on this collection using the provided `ClientSession`.
     pub async fn create_indexes_with_session(
         &self,
         indexes: impl IntoIterator<Item = IndexModel>,
@@ -545,16 +545,16 @@ impl<T> Collection<T> {
     /// Drops the index specified by `name` from this collection.
     pub async fn drop_index(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<DropIndexOptions>>,
     ) -> Result<()> {
         self.drop_index_common(name, options, None).await
     }
 
-    /// Drop the index specified by `name` from the collection using an explicit session.
+    /// Drops the index specified by `name` from this collection using the provided `ClientSession`.
     pub async fn drop_index_with_session(
         &self,
-        name: &str,
+        name: impl AsRef<str>,
         options: impl Into<Option<DropIndexOptions>>,
         session: &mut ClientSession,
     ) -> Result<()> {
@@ -566,7 +566,7 @@ impl<T> Collection<T> {
         self.drop_indexes_common(None, options, None).await
     }
 
-    /// Drop all indexes associated with the collection using an explicit session.
+    /// Drops all indexes associated with this collection using the provided `ClientSession`.
     pub async fn drop_indexes_with_session(
         &self,
         options: impl Into<Option<DropIndexOptions>>,
@@ -588,7 +588,7 @@ impl<T> Collection<T> {
             .map(|(spec, session)| Cursor::new(client.clone(), spec, session))
     }
 
-    /// List all indexes on the collection using an explicit session.
+    /// Lists all indexes on this collection using the provided `ClientSession`.
     pub async fn list_indexes_with_session(
         &self,
         options: impl Into<Option<ListIndexOptions>>,

src/results.rs

@@ -101,20 +101,6 @@ pub struct CreateIndexResult {
     pub commit_quorum: Option<CommitQuorum>,
 }
 
-impl From<CreateIndexesResult> for CreateIndexResult {
-    fn from(result: CreateIndexesResult) -> Self {
-        Self {
-            // Safe unwrap because a successful `createIndex` command will always have names.
-            index_name: result.index_names.into_iter().next().unwrap(),
-            created_collection_automatically: result.created_collection_automatically,
-            num_indexes_before: result.num_indexes_before,
-            num_indexes_after: result.num_indexes_after,
-            note: result.note,
-            commit_quorum: result.commit_quorum,
-        }
-    }
-}
-
 /// Information about the indexes created as a result of a
 /// [`Collection::create_indexes`](../struct.Collection.html#method.create_indexes).
 #[derive(Debug, Clone, PartialEq)]
@@ -139,6 +125,19 @@ pub struct CreateIndexesResult {
     pub commit_quorum: Option<CommitQuorum>,
 }
 
+impl CreateIndexesResult {
+    pub(crate) fn into_create_index_result(self) -> CreateIndexResult {
+        CreateIndexResult {
+            index_name: self.index_names.into_iter().next().unwrap(),
+            created_collection_automatically: self.created_collection_automatically,
+            num_indexes_before: self.num_indexes_before,
+            num_indexes_after: self.num_indexes_after,
+            note: self.note,
+            commit_quorum: self.commit_quorum,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub(crate) struct GetMoreResult<T> {
     pub(crate) batch: VecDeque<T>,

src/sync/coll.rs

@@ -6,12 +6,15 @@ use super::{ClientSession, Cursor, SessionCursor};
 use crate::{
     bson::{Bson, Document},
     error::Result,
+    index::IndexModel,
     options::{
         AggregateOptions,
         CountOptions,
+        CreateIndexOptions,
         DeleteOptions,
         DistinctOptions,
         DropCollectionOptions,
+        DropIndexOptions,
         EstimatedDocumentCountOptions,
         FindOneAndDeleteOptions,
         FindOneAndReplaceOptions,
@@ -20,14 +23,22 @@ use crate::{
         FindOptions,
         InsertManyOptions,
         InsertOneOptions,
+        ListIndexOptions,
         ReadConcern,
         ReplaceOptions,
         SelectionCriteria,
         UpdateModifications,
         UpdateOptions,
         WriteConcern,
     },
-    results::{DeleteResult, InsertManyResult, InsertOneResult, UpdateResult},
+    results::{
+        CreateIndexResult,
+        CreateIndexesResult,
+        DeleteResult,
+        InsertManyResult,
+        InsertOneResult,
+        UpdateResult,
+    },
     Collection as AsyncCollection,
     Namespace,
     RUNTIME,
@@ -210,6 +221,52 @@ impl<T> Collection<T> {
         ))
     }
 
+    /// Creates the given index on this collection.
+    pub fn create_index(
+        &self,
+        index: IndexModel,
+        options: impl Into<Option<CreateIndexOptions>>,
+    ) -> Result<CreateIndexResult> {
+        RUNTIME.block_on(self.async_collection.create_index(index, options))
+    }
+
+    /// Creates the given index on this collection using the provided `ClientSession`.
+    pub fn create_index_with_session(
+        &self,
+        index: IndexModel,
+        options: impl Into<Option<CreateIndexOptions>>,
+        session: &mut ClientSession,
+    ) -> Result<CreateIndexResult> {
+        RUNTIME.block_on(self.async_collection.create_index_with_session(
+            index,
+            options,
+            &mut session.async_client_session,
+        ))
+    }
+
+    /// Creates the given indexes on this collection.
+    pub fn create_indexes(
+        &self,
+        indexes: impl IntoIterator<Item = IndexModel>,
+        options: impl Into<Option<CreateIndexOptions>>,
+    ) -> Result<CreateIndexesResult> {
+        RUNTIME.block_on(self.async_collection.create_indexes(indexes, options))
+    }
+
+    /// Creates the given indexes on this collection using the provided `ClientSession`.
+    pub fn create_indexes_with_session(
+        &self,
+        indexes: impl IntoIterator<Item = IndexModel>,
+        options: impl Into<Option<CreateIndexOptions>>,
+        session: &mut ClientSession,
+    ) -> Result<CreateIndexesResult> {
+        RUNTIME.block_on(self.async_collection.create_indexes_with_session(
+            indexes,
+            options,
+            &mut session.async_client_session,
+        ))
+    }
+
     /// Deletes all documents stored in the collection matching `query`.
     pub fn delete_many(
         &self,
@@ -316,6 +373,86 @@ impl<T> Collection<T> {
         )
     }
 
+    /// Drops the index specified by `name` from this collection.
+    pub fn drop_index(
+        &self,
+        name: impl AsRef<str>,
+        options: impl Into<Option<DropIndexOptions>>,
+    ) -> Result<()> {
+        RUNTIME.block_on(self.async_collection.drop_index(name, options))
+    }
+
+    /// Drops the index specified by `name` from this collection using the provided `ClientSession`.
+    pub fn drop_index_with_session(
+        &self,
+        name: impl AsRef<str>,
+        options: impl Into<Option<DropIndexOptions>>,
+        session: &mut ClientSession,
+    ) -> Result<()> {
+        RUNTIME.block_on(self.async_collection.drop_index_with_session(
+            name,
+            options,
+            &mut session.async_client_session,
+        ))
+    }
+
+    /// Drops all indexes associated with this collection.
+    pub fn drop_indexes(&self, options: impl Into<Option<DropIndexOptions>>) -> Result<()> {
+        RUNTIME.block_on(self.async_collection.drop_indexes(options))
+    }
+
+    /// Drops all indexes associated with this collection using the provided `ClientSession`.
+    pub fn drop_indexes_with_session(
+        &self,
+        options: impl Into<Option<DropIndexOptions>>,
+        session: &mut ClientSession,
+    ) -> Result<()> {
+        RUNTIME.block_on(
+            self.async_collection
+                .drop_indexes_with_session(options, &mut session.async_client_session),
+        )
+    }
+
+    /// Lists all indexes on this collection.
+    pub fn list_indexes(
+        &self,
+        options: impl Into<Option<ListIndexOptions>>,
+    ) -> Result<Cursor<IndexModel>> {
+        RUNTIME
+            .block_on(self.async_collection.list_indexes(options))
+            .map(Cursor::new)
+    }
+
+    /// Lists all indexes on this collection using the provided `ClientSession`.
+    pub fn list_indexes_with_session(
+        &self,
+        options: impl Into<Option<ListIndexOptions>>,
+        session: &mut ClientSession,
+    ) -> Result<SessionCursor<IndexModel>> {
+        RUNTIME
+            .block_on(
+                self.async_collection
+                    .list_indexes_with_session(options, &mut session.async_client_session),
+            )
+            .map(SessionCursor::new)
+    }
+
+    /// Gets the names of all indexes on the collection.
+    pub fn list_index_names(&self) -> Result<Vec<String>> {
+        RUNTIME.block_on(self.async_collection.list_index_names())
+    }
+
+    /// Gets the names of all indexes on the collection using the provided `ClientSession`.
+    pub fn list_index_names_with_session(
+        &self,
+        session: &mut ClientSession,
+    ) -> Result<Vec<String>> {
+        RUNTIME.block_on(
+            self.async_collection
+                .list_index_names_with_session(&mut session.async_client_session),
+        )
+    }
+
     /// Updates all documents matching `query` in the collection using the provided `ClientSession`.
     ///
     /// Both `Document` and `Vec<Document>` implement `Into<UpdateModifications>`, so either can be