RUST-735 Remove Document as default generic type on Collection and Cursor (#323)

Author: patrickfreed

.evergreen/aws-ecs-test/src/main.rs

@@ -1,4 +1,4 @@
-use mongodb::Client;
+use mongodb::{bson::Document, Client};
 
 #[tokio::main]
 async fn main() {
@@ -7,7 +7,7 @@ async fn main() {
 
     client
         .database("aws")
-        .collection("somecoll")
+        .collection::<Document>("somecoll")
         .find_one(None, None)
         .await
         .unwrap();

README.md

@@ -97,11 +97,11 @@ for collection_name in db.list_collection_names(None).await? {
 ```
 #### Inserting documents into a collection
 ```rust
-use mongodb::bson::doc;
+use mongodb::bson::{doc, Document};
 ```
 ```rust
 // Get a handle to a collection in the database.
-let collection = db.collection("books");
+let collection = db.collection::<Document>("books");
 
 let docs = vec![
     doc! { "title": "1984", "author": "George Orwell" },
@@ -147,14 +147,14 @@ The driver also provides a blocking sync API. See the [Installation](#enabling-t
 The various sync-specific types are found in the `mongodb::sync` submodule rather than in the crate's top level like in the async API. The sync API calls through to the async API internally though, so it looks and behaves similarly to it.
 ```rust
 use mongodb::{
-    bson::{doc, Bson},
+    bson::{doc, Bson, Document},
     sync::Client,
 };
 ```
 ```rust
 let client = Client::with_uri_str("mongodb://localhost:27017")?;
 let database = client.database("mydb");
-let collection = database.collection("books");
+let collection = database.collection::<Document>("books");
 
 let docs = vec![
     doc! { "title": "1984", "author": "George Orwell" },

src/client/mod.rs

@@ -42,7 +42,7 @@ const DEFAULT_SERVER_SELECTION_TIMEOUT: Duration = Duration::from_secs(30);
 ///
 /// ```rust
 /// # #[cfg(not(feature = "sync"))]
-/// # use mongodb::{Client, error::Result};
+/// # use mongodb::{bson::Document, Client, error::Result};
 /// # #[cfg(feature = "async-std-runtime")]
 /// # use async_std::task;
 /// # #[cfg(feature = "tokio-runtime")]
@@ -56,7 +56,7 @@ const DEFAULT_SERVER_SELECTION_TIMEOUT: Duration = Duration::from_secs(30);
 ///     let client_ref = client.clone();
 ///
 ///     task::spawn(async move {
-///         let collection = client_ref.database("items").collection(&format!("coll{}", i));
+///         let collection = client_ref.database("items").collection::<Document>(&format!("coll{}", i));
 ///
 ///         // Do something with the collection
 ///     });

src/client/session/test.rs

@@ -1,5 +1,6 @@
 use std::{future::Future, time::Duration};
 
+use bson::Document;
 use futures::stream::StreamExt;
 use tokio::sync::RwLockReadGuard;
 
@@ -38,7 +39,9 @@ macro_rules! db_op {
 macro_rules! collection_op {
     ($test_name:expr, $coll:ident, $body:expr) => {
         |client| async move {
-            let $coll = client.database($test_name).collection($test_name);
+            let $coll = client
+                .database($test_name)
+                .collection::<bson::Document>($test_name);
             $body.await.unwrap();
         }
     };
@@ -285,7 +288,7 @@ async fn cluster_time_in_commands() {
     cluster_time_test("aggregate", |client| async move {
         client
             .database(function_name!())
-            .collection(function_name!())
+            .collection::<Document>(function_name!())
             .aggregate(vec![doc! { "$match": { "x": 1 } }], None)
             .await
     })
@@ -294,7 +297,7 @@ async fn cluster_time_in_commands() {
     cluster_time_test("find", |client| async move {
         client
             .database(function_name!())
-            .collection(function_name!())
+            .collection::<Document>(function_name!())
             .find(doc! {}, None)
             .await
     })
@@ -303,7 +306,7 @@ async fn cluster_time_in_commands() {
     cluster_time_test("insert", |client| async move {
         client
             .database(function_name!())
-            .collection(function_name!())
+            .collection::<Document>(function_name!())
             .insert_one(doc! {}, None)
             .await
     })

src/coll/mod.rs

@@ -215,7 +215,7 @@ where
         &self,
         pipeline: impl IntoIterator<Item = Document>,
         options: impl Into<Option<AggregateOptions>>,
-    ) -> Result<Cursor> {
+    ) -> Result<Cursor<Document>> {
         let mut options = options.into();
         resolve_options!(
             self,
@@ -240,7 +240,7 @@ where
         pipeline: impl IntoIterator<Item = Document>,
         options: impl Into<Option<AggregateOptions>>,
         session: &mut ClientSession,
-    ) -> Result<SessionCursor> {
+    ) -> Result<SessionCursor<Document>> {
         let mut options = options.into();
         resolve_options!(
             self,

src/cursor/mod.rs

@@ -43,11 +43,11 @@ use common::{GenericCursor, GetMoreProvider, GetMoreProviderResult};
 ///
 /// ```rust
 /// # use futures::stream::StreamExt;
-/// # use mongodb::{Client, error::Result};
+/// # use mongodb::{bson::Document, Client, error::Result};
 /// #
 /// # async fn do_stuff() -> Result<()> {
 /// # let client = Client::with_uri_str("mongodb://example.com").await?;
-/// # let coll = client.database("foo").collection("bar");
+/// # let coll = client.database("foo").collection::<Document>("bar");
 /// # let mut cursor = coll.find(None, None).await?;
 /// #
 /// while let Some(doc) = cursor.next().await {
@@ -81,7 +81,7 @@ use common::{GenericCursor, GetMoreProvider, GetMoreProviderResult};
 /// # }
 /// ```
 #[derive(Debug)]
-pub struct Cursor<T = Document>
+pub struct Cursor<T>
 where
     T: DeserializeOwned + Unpin,
 {
@@ -139,7 +139,7 @@ where
         let coll = self
             .client
             .database(ns.db.as_str())
-            .collection(ns.coll.as_str());
+            .collection::<Document>(ns.coll.as_str());
         let cursor_id = self.wrapped_cursor.id();
         RUNTIME.execute(async move { coll.kill_cursor(cursor_id).await });
     }

src/cursor/session.rs

@@ -24,12 +24,12 @@ use crate::{
 ///
 /// ```rust
 /// # use futures::stream::StreamExt;
-/// # use mongodb::{Client, error::Result, ClientSession, SessionCursor};
+/// # use mongodb::{bson::Document, Client, error::Result, ClientSession, SessionCursor};
 /// #
 /// # async fn do_stuff() -> Result<()> {
 /// # let client = Client::with_uri_str("mongodb://example.com").await?;
 /// # let mut session = client.start_session(None).await?;
-/// # let coll = client.database("foo").collection("bar");
+/// # let coll = client.database("foo").collection::<Document>("bar");
 /// # let mut cursor = coll.find_with_session(None, None, &mut session).await?;
 /// #
 /// while let Some(doc) = cursor.with_session(&mut session).next().await {
@@ -40,7 +40,7 @@ use crate::{
 /// # }
 /// ```
 #[derive(Debug)]
-pub struct SessionCursor<T = Document>
+pub struct SessionCursor<T>
 where
     T: DeserializeOwned + Unpin,
 {
@@ -105,7 +105,7 @@ where
         let coll = self
             .client
             .database(ns.db.as_str())
-            .collection(ns.coll.as_str());
+            .collection::<Document>(ns.coll.as_str());
         let cursor_id = self.info.id;
         RUNTIME.execute(async move { coll.kill_cursor(cursor_id).await });
     }

src/db/mod.rs

@@ -39,7 +39,7 @@ use crate::{
 /// ```rust
 /// 
 /// # #[cfg(not(feature = "sync"))]
-/// # use mongodb::{Client, error::Result};
+/// # use mongodb::{bson::Document, Client, error::Result};
 /// # #[cfg(feature = "async-std-runtime")]
 /// # use async_std::task;
 /// # #[cfg(feature = "tokio-runtime")]
@@ -55,7 +55,7 @@ use crate::{
 ///     let db_ref = db.clone();
 ///
 ///     task::spawn(async move {
-///         let collection = db_ref.collection(&format!("coll{}", i));
+///         let collection = db_ref.collection::<Document>(&format!("coll{}", i));
 ///
 ///         // Do something with the collection
 ///     });
@@ -129,45 +129,26 @@ impl Database {
         self.inner.write_concern.as_ref()
     }
 
-    /// Gets a handle to a collection specified by `name` of the database. The `Collection` options
-    /// (e.g. read preference and write concern) will default to those of the `Database`.
-    ///
-    /// This method does not send or receive anything across the wire to the database, so it can be
-    /// used repeatedly without incurring any costs from I/O.
-    pub fn collection(&self, name: &str) -> Collection {
-        Collection::new(self.clone(), name, None)
-    }
-
     /// Gets a handle to a collection with type `T` specified by `name` of the database. The
     /// `Collection` options (e.g. read preference and write concern) will default to those of the
     /// `Database`.
     ///
     /// This method does not send or receive anything across the wire to the database, so it can be
     /// used repeatedly without incurring any costs from I/O.
-    pub fn collection_with_type<T>(&self, name: &str) -> Collection<T>
+    pub fn collection<T>(&self, name: &str) -> Collection<T>
     where
         T: Serialize + DeserializeOwned + Unpin + Debug,
     {
         Collection::new(self.clone(), name, None)
     }
 
-    /// Gets a handle to a collection specified by `name` in the cluster the `Client` is connected
-    /// to. Operations done with this `Collection` will use the options specified by `options` by
-    /// default and will otherwise default to those of the `Database`.
-    ///
-    /// This method does not send or receive anything across the wire to the database, so it can be
-    /// used repeatedly without incurring any costs from I/O.
-    pub fn collection_with_options(&self, name: &str, options: CollectionOptions) -> Collection {
-        Collection::new(self.clone(), name, Some(options))
-    }
-
     /// Gets a handle to a collection with type `T` specified by `name` in the cluster the `Client`
     /// is connected to. Operations done with this `Collection` will use the options specified by
     /// `options` by default and will otherwise default to those of the `Database`.
     ///
     /// This method does not send or receive anything across the wire to the database, so it can be
     /// used repeatedly without incurring any costs from I/O.
-    pub fn collection_with_type_and_options<T>(
+    pub fn collection_with_options<T>(
         &self,
         name: &str,
         options: CollectionOptions,
@@ -213,7 +194,7 @@ impl Database {
         &self,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<ListCollectionsOptions>>,
-    ) -> Result<Cursor> {
+    ) -> Result<Cursor<Document>> {
         let list_collections = ListCollections::new(
             self.name().to_string(),
             filter.into(),
@@ -234,7 +215,7 @@ impl Database {
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<ListCollectionsOptions>>,
         session: &mut ClientSession,
-    ) -> Result<SessionCursor> {
+    ) -> Result<SessionCursor<Document>> {
         let list_collections = ListCollections::new(
             self.name().to_string(),
             filter.into(),
@@ -392,7 +373,7 @@ impl Database {
         &self,
         pipeline: impl IntoIterator<Item = Document>,
         options: impl Into<Option<AggregateOptions>>,
-    ) -> Result<Cursor> {
+    ) -> Result<Cursor<Document>> {
         let mut options = options.into();
         resolve_options!(
             self,
@@ -417,7 +398,7 @@ impl Database {
         pipeline: impl IntoIterator<Item = Document>,
         options: impl Into<Option<AggregateOptions>>,
         session: &mut ClientSession,
-    ) -> Result<SessionCursor> {
+    ) -> Result<SessionCursor<Document>> {
         let mut options = options.into();
         resolve_options!(
             self,

src/sdam/description/topology/server_selection/test/in_window.rs

@@ -1,6 +1,7 @@
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use approx::abs_diff_eq;
+use bson::Document;
 use semver::VersionReq;
 use serde::Deserialize;
 use tokio::sync::RwLockWriteGuard;
@@ -157,7 +158,7 @@ async fn load_balancing_test() {
         for _ in 0..10 {
             let collection = client
                 .database("load_balancing_test")
-                .collection("load_balancing_test");
+                .collection::<Document>("load_balancing_test");
             handles.push(
                 RUNTIME
                     .spawn(async move {

src/sync/client.rs

@@ -26,7 +26,7 @@ use crate::{
 /// so it can safely be shared across threads. For example:
 ///
 /// ```rust
-/// # use mongodb::{sync::Client, error::Result};
+/// # use mongodb::{bson::Document, sync::Client, error::Result};
 /// #
 /// # fn start_workers() -> Result<()> {
 /// let client = Client::with_uri_str("mongodb://example.com")?;
@@ -35,7 +35,7 @@ use crate::{
 ///     let client_ref = client.clone();
 ///
 ///     std::thread::spawn(move || {
-///         let collection = client_ref.database("items").collection(&format!("coll{}", i));
+///         let collection = client_ref.database("items").collection::<Document>(&format!("coll{}", i));
 ///
 ///         // Do something with the collection
 ///     });