mongodb 3.6.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

use serde::Serialize;
use std::str::FromStr;

use crate::error::{Error, ErrorKind, Result};

/// The compressors that may be used to compress messages sent to and decompress messages returned
/// from the server. Note that each variant requires enabling a corresponding feature flag.
#[derive(Clone, Debug, PartialEq, Serialize)]
#[non_exhaustive]
pub enum Compressor {
    /// `zstd` compression. See [the `zstd` manual](http://facebook.github.io/zstd/zstd_manual.html)
    /// for more information.
    #[cfg(feature = "zstd-compression")]
    Zstd {
        /// The compression level to use. It is an error to specify a value outside of the
        /// supported compression levels returned by [zstd::compression_level_range]. If no value
        /// is specified, the default value ([zstd::DEFAULT_COMPRESSION_LEVEL]) will be used.
        /// Higher levels correlate to smaller compression but slower performance.
        level: Option<i32>,
    },
    /// `zlib` compression. See [the `zlib` documentation](https://zlib.net/) for more information.
    #[cfg(feature = "zlib-compression")]
    Zlib {
        /// The compression level to use. If no value is specified, the default value
        /// ([flate2::Compression::default]) will be used. Higher levels correlate to smaller
        /// compression but slower performance.
        level: Option<u32>,
    },
    /// `snappy` compression. See [the `snappy` documentation](http://google.github.io/snappy/)
    /// for more information.
    #[cfg(feature = "snappy-compression")]
    Snappy,
}

impl Compressor {
    pub(crate) fn name(&self) -> &'static str {
        match *self {
            #[cfg(feature = "zstd-compression")]
            Compressor::Zstd { .. } => "zstd",
            #[cfg(feature = "zlib-compression")]
            Compressor::Zlib { .. } => "zlib",
            #[cfg(feature = "snappy-compression")]
            Compressor::Snappy => "snappy",
        }
    }

    pub(crate) fn id(&self) -> u8 {
        match self {
            #[cfg(feature = "zstd-compression")]
            Self::Zstd { .. } => super::ZSTD_COMPRESSOR_ID,
            #[cfg(feature = "zlib-compression")]
            Self::Zlib { .. } => super::ZLIB_COMPRESSOR_ID,
            #[cfg(feature = "snappy-compression")]
            Self::Snappy => super::SNAPPY_COMPRESSOR_ID,
        }
    }

    pub(crate) fn validate(&self) -> Result<()> {
        #[cfg(feature = "zstd-compression")]
        if let Self::Zstd { level: Some(level) } = self {
            let valid_levels = zstd::compression_level_range();
            if !valid_levels.contains(level) {
                return Err(ErrorKind::InvalidArgument {
                    message: format!(
                        "Invalid zstd compression level {level}: compression level must be within \
                         the range {valid_levels:?}"
                    ),
                }
                .into());
            }
        }

        #[cfg(feature = "zlib-compression")]
        if let Self::Zlib { level: Some(level) } = self {
            if *level > 9 {
                return Err(ErrorKind::InvalidArgument {
                    message: format!(
                        "Invalid zlib compression level {level}: compression level must be \
                         between 0 and 9 (inclusive)"
                    ),
                }
                .into());
            }
        }

        Ok(())
    }

    #[cfg(feature = "zlib-compression")]
    pub(crate) fn write_zlib_level(&mut self, uri_level: i32) -> Result<()> {
        // This pattern is irrefutable when only zlib-compression is enabled.
        #[allow(irrefutable_let_patterns)]
        if let Compressor::Zlib { ref mut level } = *self {
            if uri_level == -1 {
                *level = None;
            } else {
                let zlib_compression_level =
                    u32::try_from(uri_level).map_err(|_| ErrorKind::InvalidArgument {
                        message: format!(
                            "Invalid zlib compression level specified: {uri_level}\nzlib \
                             compression level must be a nonnegative integer or -1 to use the \
                             default compression level"
                        ),
                    })?;
                *level = Some(zlib_compression_level);
            }
        }
        Ok(())
    }
}

impl FromStr for Compressor {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        match s.to_lowercase().as_str() {
            #[cfg(feature = "zstd-compression")]
            "zstd" => Ok(Self::Zstd { level: None }),
            #[cfg(feature = "zlib-compression")]
            "zlib" => Ok(Self::Zlib { level: None }),
            #[cfg(feature = "snappy-compression")]
            "snappy" => Ok(Self::Snappy),
            other if other == "zstd" || other == "zlib" || other == "snappy" => {
                Err(ErrorKind::InvalidArgument {
                    message: format!(
                        "Enable the {other}-compression feature flag to use {other} compression"
                    ),
                }
                .into())
            }
            other => Err(ErrorKind::InvalidArgument {
                message: format!("Unsupported compressor: {other}"),
            }
            .into()),
        }
    }
}