mongodb 3.3.0

The official MongoDB driver for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[cfg(feature = "in-use-encryption")]
use crate::bson::Document;

use crate::{
    coll::options::DropCollectionOptions,
    db::options::DropDatabaseOptions,
    error::Result,
    operation::drop_database,
    options::WriteConcern,
    ClientSession,
    Collection,
    Database,
};

use super::{action_impl, deeplink, export_doc, option_setters, options_doc, CollRef};

impl Database {
    /// Drops the database, deleting all data, collections, and indexes stored in it.
    ///
    /// `await` will return d[`Result<()>`].
    #[deeplink]
    #[options_doc(drop_db)]
    pub fn drop(&self) -> DropDatabase {
        DropDatabase {
            db: self,
            options: None,
            session: None,
        }
    }
}

#[cfg(feature = "sync")]
impl crate::sync::Database {
    /// Drops the database, deleting all data, collections, and indexes stored in it.
    ///
    /// [`run`](DropDatabase::run) will return d[`Result<()>`].
    #[deeplink]
    #[options_doc(drop_db, sync)]
    pub fn drop(&self) -> DropDatabase {
        self.async_database.drop()
    }
}

/// Drops the database, deleting all data, collections, and indexes stored in it.  Construct with
/// [`Database::drop`].
#[must_use]
pub struct DropDatabase<'a> {
    db: &'a Database,
    options: Option<DropDatabaseOptions>,
    session: Option<&'a mut ClientSession>,
}

#[option_setters(crate::db::options::DropDatabaseOptions)]
#[export_doc(drop_db)]
impl<'a> DropDatabase<'a> {
    /// Runs the drop using the provided session.
    pub fn session(mut self, value: impl Into<&'a mut ClientSession>) -> Self {
        self.session = Some(value.into());
        self
    }
}

#[action_impl]
impl<'a> Action for DropDatabase<'a> {
    type Future = DropDatabaseFuture;

    async fn execute(mut self) -> Result<()> {
        resolve_options!(self.db, self.options, [write_concern]);
        let op = drop_database::DropDatabase::new(self.db.name().to_string(), self.options);
        self.db.client().execute_operation(op, self.session).await
    }
}

impl<T> Collection<T>
where
    T: Send + Sync,
{
    /// Drops the collection, deleting all data and indexes stored in it.
    ///
    /// `await` will return d[`Result<()>`].
    #[deeplink]
    #[options_doc(drop_coll)]
    pub fn drop(&self) -> DropCollection {
        DropCollection {
            cr: CollRef::new(self),
            options: None,
            session: None,
        }
    }
}

#[cfg(feature = "sync")]
impl<T> crate::sync::Collection<T>
where
    T: Send + Sync,
{
    /// Drops the collection, deleting all data and indexes stored in it.
    ///
    /// [`run`](DropCollection::run) will return d[`Result<()>`].
    #[deeplink]
    #[options_doc(drop_coll, sync)]
    pub fn drop(&self) -> DropCollection {
        self.async_collection.drop()
    }
}

/// Drops the collection, deleting all data and indexes stored in it.  Construct with
/// [`Collection::drop`].
#[must_use]
pub struct DropCollection<'a> {
    pub(crate) cr: CollRef<'a>,
    pub(crate) options: Option<DropCollectionOptions>,
    pub(crate) session: Option<&'a mut ClientSession>,
}

#[option_setters(crate::coll::options::DropCollectionOptions)]
#[export_doc(drop_coll)]
impl<'a> DropCollection<'a> {
    /// Runs the drop using the provided session.
    pub fn session(mut self, value: impl Into<&'a mut ClientSession>) -> Self {
        self.session = Some(value.into());
        self
    }
}

// Action impl in src/coll/action/drop.rs