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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use crate::bson::{doc, Bson};

#[cfg(docsrs)]
use crate::gridfs::FilesCollectionDocument;
use crate::{
    action::action_impl,
    error::{ErrorKind, GridFsErrorKind, GridFsFileIdentifier, Result},
    gridfs::GridFsBucket,
};

impl GridFsBucket {
    /// Deletes the [`FilesCollectionDocument`] with the given `id` and its associated chunks from
    /// this bucket. This method returns an error if the `id` does not match any files in the
    /// bucket.
    ///
    /// `await` will return [`Result<()>`].
    pub fn delete(&self, id: Bson) -> Delete {
        Delete { bucket: self, id }
    }

    /// Deletes the [`FilesCollectionDocument`] with the given name and its associated chunks from
    /// this bucket. This method returns an error if the name does not match any files in the
    /// bucket.
    ///
    /// `await` will return [`Result<()>`].
    pub fn delete_by_name(&self, filename: impl Into<String>) -> DeleteByName {
        DeleteByName {
            bucket: self,
            filename: filename.into(),
        }
    }
}

#[cfg(feature = "sync")]
impl crate::sync::gridfs::GridFsBucket {
    /// Deletes the [`FilesCollectionDocument`] with the given `id` and its associated chunks from
    /// this bucket. This method returns an error if the `id` does not match any files in the
    /// bucket.
    ///
    /// [`run`](Delete::run) will return [`Result<()>`].
    pub fn delete(&self, id: Bson) -> Delete {
        self.async_bucket.delete(id)
    }

    /// Deletes the [`FilesCollectionDocument`] with the given name and its associated chunks from
    /// this bucket. This method returns an error if the name does not match any files in the
    /// bucket.
    ///
    /// [`run`](DeleteByName::run) will return [`Result<()>`].
    pub fn delete_by_name(&self, filename: impl Into<String>) -> DeleteByName {
        self.async_bucket.delete_by_name(filename)
    }
}

/// Deletes a specific [`FilesCollectionDocument`] and its associated chunks.  Construct with
/// [`GridFsBucket::delete`].
#[must_use]
pub struct Delete<'a> {
    bucket: &'a GridFsBucket,
    id: Bson,
}

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

    async fn execute(self) -> Result<()> {
        let delete_result = self
            .bucket
            .files()
            .delete_one(doc! { "_id": self.id.clone() })
            .await?;
        // Delete chunks regardless of whether a file was found. This will remove any possibly
        // orphaned chunks.
        self.bucket
            .chunks()
            .delete_many(doc! { "files_id": self.id.clone() })
            .await?;

        if delete_result.deleted_count == 0 {
            return Err(ErrorKind::GridFs(GridFsErrorKind::FileNotFound {
                identifier: GridFsFileIdentifier::Id(self.id),
            })
            .into());
        }

        Ok(())
    }
}

/// Deletes a named [`FilesCollectionDocument`] and its associated chunks.  Construct with
/// [`GridFsBucket::delete_by_name`].
#[must_use]
pub struct DeleteByName<'a> {
    bucket: &'a GridFsBucket,
    filename: String,
}

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

    async fn execute(self) -> Result<()> {
        use futures_util::stream::{StreamExt, TryStreamExt};
        let ids: Vec<_> = self
            .bucket
            .files()
            .find(doc! { "filename": self.filename.clone() })
            .projection(doc! { "_id": 1 })
            .await?
            .with_type::<crate::bson::Document>()
            .map(|r| match r {
                Ok(mut d) => d
                    .remove("_id")
                    .ok_or_else(|| crate::error::Error::internal("_id field expected")),
                Err(e) => Err(e),
            })
            .try_collect()
            .await?;

        let count = self
            .bucket
            .files()
            .delete_many(doc! { "_id": { "$in": ids.clone() } })
            .await?
            .deleted_count;
        self.bucket
            .chunks()
            .delete_many(doc! { "files_id": { "$in": ids } })
            .await?;

        if count == 0 {
            return Err(ErrorKind::GridFs(GridFsErrorKind::FileNotFound {
                identifier: GridFsFileIdentifier::Filename(self.filename),
            })
            .into());
        }

        Ok(())
    }
}